sig
module Std :
sig
type 'a printer = Format.formatter -> 'a -> unit
module type Printable =
sig
type t
val to_string : Bap.Std.Printable.t -> string
val str : unit -> Bap.Std.Printable.t -> string
val pps : unit -> Bap.Std.Printable.t -> string
val ppo : Pervasives.out_channel -> Bap.Std.Printable.t -> unit
val pp : Format.formatter -> t -> unit
end
module type Regular =
sig
type t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module type Integer =
sig
type t
val zero : Bap.Std.Integer.t
val one : Bap.Std.Integer.t
val succ : Bap.Std.Integer.t -> Bap.Std.Integer.t
val pred : Bap.Std.Integer.t -> Bap.Std.Integer.t
val abs : Bap.Std.Integer.t -> Bap.Std.Integer.t
val neg : Bap.Std.Integer.t -> Bap.Std.Integer.t
val add :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val sub :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val mul :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val div :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val modulo :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val lnot : Bap.Std.Integer.t -> Bap.Std.Integer.t
val logand :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val logor :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val logxor :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val lshift :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val rshift :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val arshift :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( ~- ) : Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( + ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( - ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( * ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( / ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( mod ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( land ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( lor ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( lxor ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( lsl ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( lsr ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
val ( asr ) :
Bap.Std.Integer.t -> Bap.Std.Integer.t -> Bap.Std.Integer.t
end
module Regular :
sig
module Make :
functor
(M : sig
type t
val pp : Format.formatter -> t -> unit
val hash : Bap.Std.Regular.Make.t -> int
val module_name : string
end) ->
sig
val to_string : M.t -> string
val str : unit -> M.t -> string
val pps : unit -> M.t -> string
val ppo : out_channel -> M.t -> unit
val pp : Format.formatter -> M.t -> unit
val ( >= ) : M.t -> M.t -> bool
val ( <= ) : M.t -> M.t -> bool
val ( = ) : M.t -> M.t -> bool
val ( > ) : M.t -> M.t -> bool
val ( < ) : M.t -> M.t -> bool
val ( <> ) : M.t -> M.t -> bool
val equal : M.t -> M.t -> bool
val compare : M.t -> M.t -> int
val min : M.t -> M.t -> M.t
val max : M.t -> M.t -> M.t
val ascending : M.t -> M.t -> int
val descending : M.t -> M.t -> int
val between : M.t -> low:M.t -> high:M.t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : M.t -> M.t -> bool
val ( <= ) : M.t -> M.t -> bool
val ( = ) : M.t -> M.t -> bool
val ( > ) : M.t -> M.t -> bool
val ( < ) : M.t -> M.t -> bool
val ( <> ) : M.t -> M.t -> bool
val equal : M.t -> M.t -> bool
val compare : M.t -> M.t -> int
val min : M.t -> M.t -> M.t
val max : M.t -> M.t -> M.t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:M.t Core_kernel.Comparable_intf.bound ->
M.t Core_kernel.Validate.check
val validate_ubound :
max:M.t Core_kernel.Comparable_intf.bound ->
M.t Core_kernel.Validate.check
val validate_bound :
min:M.t Core_kernel.Comparable_intf.bound ->
max:M.t Core_kernel.Comparable_intf.bound ->
M.t Core_kernel.Validate.check
val comparator :
(M.t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = M.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = M.t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = M.t end
val hash : M.t -> int
val hashable :
M.t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = M.t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = M.t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t :
('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t :
('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = M.t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = M.t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
end
module type Trie =
sig
type 'a t
type key
val create : unit -> 'a Bap.Std.Trie.t
val add :
'a Bap.Std.Trie.t -> key:Bap.Std.Trie.key -> data:'a -> unit
val change :
'a Bap.Std.Trie.t ->
Bap.Std.Trie.key -> ('a option -> 'a option) -> unit
val find : 'a Bap.Std.Trie.t -> Bap.Std.Trie.key -> 'a option
val remove : 'a Bap.Std.Trie.t -> Bap.Std.Trie.key -> unit
val longest_match :
'a Bap.Std.Trie.t -> Bap.Std.Trie.key -> (int * 'a) option
val length : 'a Bap.Std.Trie.t -> int
val pp : 'a Bap.Std.printer -> 'a Bap.Std.Trie.t Bap.Std.printer
end
module Trie :
sig
module type Key =
sig
type t
type token
val length : Bap.Std.Trie.Key.t -> int
val nth_token :
Bap.Std.Trie.Key.t -> int -> Bap.Std.Trie.Key.token
val token_hash : Bap.Std.Trie.Key.token -> int
end
module Make :
functor (Key : Key) ->
sig
type 'a t
type key = Key.t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module String :
sig
type 'a t
type key = string
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
type word
type addr = Bap.Std.word
module Size :
sig
type all = [ `r16 | `r32 | `r64 | `r8 ]
type 'a p = 'a constraint 'a = [< Bap.Std.Size.all ]
type t = Bap.Std.Size.all Bap.Std.Size.p
val of_int : int -> Bap.Std.Size.t Core_kernel.Std.Or_error.t
val of_int_exn : int -> Bap.Std.Size.t
val of_int_opt : int -> Bap.Std.Size.t option
val addr_of_int : int -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
val addr_of_int_exn : int -> [ `r32 | `r64 ]
val addr_of_int_opt : int -> [ `r32 | `r64 ] option
val addr_of_word_size :
Core_kernel.Std.Word_size.t -> [ `r32 | `r64 ]
val word_of_addr_size :
[ `r32 | `r64 ] -> Core_kernel.Std.Word_size.t
val to_addr_size :
Bap.Std.Size.t -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
val to_bits : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
val to_bytes : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
type size = Bap.Std.Size.t
type addr_size = [ `r32 | `r64 ] Bap.Std.Size.p
type nat1 = int
module Bitvector :
sig
type t = Bap.Std.word
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val validate_positive : t Core_kernel.Validate.check
val validate_non_negative : t Core_kernel.Validate.check
val validate_negative : t Core_kernel.Validate.check
val validate_non_positive : t Core_kernel.Validate.check
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
exception Width
type endian = LittleEndian | BigEndian
val of_string : string -> Bap.Std.Bitvector.t
val of_bool : bool -> Bap.Std.Bitvector.t
val of_int : width:int -> int -> Bap.Std.Bitvector.t
val of_int32 : ?width:int -> int32 -> Bap.Std.Bitvector.t
val of_int64 : ?width:int -> int64 -> Bap.Std.Bitvector.t
val b0 : Bap.Std.Bitvector.t
val b1 : Bap.Std.Bitvector.t
val one : int -> Bap.Std.Bitvector.t
val zero : int -> Bap.Std.Bitvector.t
val ones : int -> Bap.Std.Bitvector.t
val of_binary :
?width:int ->
Bap.Std.Bitvector.endian -> string -> Bap.Std.Bitvector.t
val to_int : Bap.Std.Bitvector.t -> int Core_kernel.Std.Or_error.t
val to_int32 :
Bap.Std.Bitvector.t -> int32 Core_kernel.Std.Or_error.t
val to_int64 :
Bap.Std.Bitvector.t -> int64 Core_kernel.Std.Or_error.t
val string_of_value : ?hex:bool -> Bap.Std.Bitvector.t -> string
val signed : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val is_zero : Bap.Std.Bitvector.t -> bool
val is_one : Bap.Std.Bitvector.t -> bool
val bitwidth : Bap.Std.Bitvector.t -> int
val extract :
?hi:int ->
?lo:int ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val extract_exn :
?hi:int -> ?lo:int -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val concat :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val ( @. ) :
Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val succ : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val pred : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
val nsucc : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val npred : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val ( ++ ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val ( -- ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
val to_bytes :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian ->
Bap.Std.Bitvector.t Core_kernel.Std.Sequence.t
val to_chars :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian -> char Core_kernel.Std.Sequence.t
val to_bits :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.endian -> bool Core_kernel.Std.Sequence.t
module Int_err :
sig
val ( !$ ) :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i1 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i4 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i8 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i16 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i32 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val i64 :
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val int :
int ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
Bap.Std.Bitvector.t ->
Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
type t = t Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
end
end
type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
module Word :
sig
type t = word
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness = Bitvector.comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val validate_positive : t Core_kernel.Validate.check
val validate_non_negative : t Core_kernel.Validate.check
val validate_negative : t Core_kernel.Validate.check
val validate_non_positive : t Core_kernel.Validate.check
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
exception Width
type endian = endian = LittleEndian | BigEndian
val of_string : string -> t
val of_bool : bool -> t
val of_int : width:int -> int -> t
val of_int32 : ?width:int -> int32 -> t
val of_int64 : ?width:int -> int64 -> t
val b0 : t
val b1 : t
val one : int -> t
val zero : int -> t
val ones : int -> t
val of_binary : ?width:int -> endian -> string -> t
val to_int : t -> int Core_kernel.Std.Or_error.t
val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
val string_of_value : ?hex:bool -> t -> string
val signed : t -> t
val is_zero : t -> bool
val is_one : t -> bool
val bitwidth : t -> int
val extract :
?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
val extract_exn : ?hi:int -> ?lo:int -> t -> t
val concat : t -> t -> t
val ( @. ) : t -> t -> t
val succ : t -> t
val pred : t -> t
val nsucc : t -> int -> t
val npred : t -> int -> t
val ( ++ ) : t -> int -> t
val ( -- ) : t -> int -> t
val to_bytes : t -> endian -> t Core_kernel.Std.Sequence.t
val to_chars : t -> endian -> char Core_kernel.Std.Sequence.t
val to_bits : t -> endian -> bool Core_kernel.Std.Sequence.t
module Int_err :
sig
val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
val i1 : t -> t Core_kernel.Std.Or_error.t
val i4 : t -> t Core_kernel.Std.Or_error.t
val i8 : t -> t Core_kernel.Std.Or_error.t
val i16 : t -> t Core_kernel.Std.Or_error.t
val i32 : t -> t Core_kernel.Std.Or_error.t
val i64 : t -> t Core_kernel.Std.Or_error.t
val int : int -> t -> t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
t -> t Core_kernel.Std.Or_error.t
type t = t Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
end
end
module Addr :
sig
type t = addr
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness = Bitvector.comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val validate_positive : t Core_kernel.Validate.check
val validate_non_negative : t Core_kernel.Validate.check
val validate_negative : t Core_kernel.Validate.check
val validate_non_positive : t Core_kernel.Validate.check
val is_positive : t -> bool
val is_non_negative : t -> bool
val is_negative : t -> bool
val is_non_positive : t -> bool
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
module Mono :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
end
exception Width
type endian = endian = LittleEndian | BigEndian
val of_string : string -> t
val of_bool : bool -> t
val of_int : width:int -> int -> t
val of_int32 : ?width:int -> int32 -> t
val of_int64 : ?width:int -> int64 -> t
val b0 : t
val b1 : t
val one : int -> t
val zero : int -> t
val ones : int -> t
val of_binary : ?width:int -> endian -> string -> t
val to_int : t -> int Core_kernel.Std.Or_error.t
val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
val string_of_value : ?hex:bool -> t -> string
val signed : t -> t
val is_zero : t -> bool
val is_one : t -> bool
val bitwidth : t -> int
val extract :
?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
val extract_exn : ?hi:int -> ?lo:int -> t -> t
val concat : t -> t -> t
val ( @. ) : t -> t -> t
val succ : t -> t
val pred : t -> t
val nsucc : t -> int -> t
val npred : t -> int -> t
val ( ++ ) : t -> int -> t
val ( -- ) : t -> int -> t
val to_bytes : t -> endian -> t Core_kernel.Std.Sequence.t
val to_chars : t -> endian -> char Core_kernel.Std.Sequence.t
val to_bits : t -> endian -> bool Core_kernel.Std.Sequence.t
module Int_err :
sig
val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
val i1 : t -> t Core_kernel.Std.Or_error.t
val i4 : t -> t Core_kernel.Std.Or_error.t
val i8 : t -> t Core_kernel.Std.Or_error.t
val i16 : t -> t Core_kernel.Std.Or_error.t
val i32 : t -> t Core_kernel.Std.Or_error.t
val i64 : t -> t Core_kernel.Std.Or_error.t
val int : int -> t -> t Core_kernel.Std.Or_error.t
val of_word_size :
Core_kernel.Std.Word_size.t ->
t -> t Core_kernel.Std.Or_error.t
type t = t Core_kernel.Std.Or_error.t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
val ( >>= ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b Core_kernel.Std.Or_error.t) ->
'b Core_kernel.Std.Or_error.t
val ( >>| ) :
'a Core_kernel.Std.Or_error.t ->
('a -> 'b) -> 'b Core_kernel.Std.Or_error.t
end
module Int_exn :
sig
type t = t
val zero : t
val one : t
val succ : t -> t
val pred : t -> t
val abs : t -> t
val neg : t -> t
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val div : t -> t -> t
val modulo : t -> t -> t
val lnot : t -> t
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lshift : t -> t -> t
val rshift : t -> t -> t
val arshift : t -> t -> t
val ( ~- ) : t -> t
val ( + ) : t -> t -> t
val ( - ) : t -> t -> t
val ( * ) : t -> t -> t
val ( / ) : t -> t -> t
val ( mod ) : t -> t -> t
val ( land ) : t -> t -> t
val ( lor ) : t -> t -> t
val ( lxor ) : t -> t -> t
val ( lsl ) : t -> t -> t
val ( lsr ) : t -> t -> t
val ( asr ) : t -> t -> t
end
module Trie :
sig
module Big :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
module Little :
sig
module Bits :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module Bytes :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
end
val memref :
?disp:int ->
?index:int -> ?scale:Bap.Std.size -> Bap.Std.addr -> Bap.Std.addr
end
module Type :
sig
type t =
Imm of Bap.Std.nat1
| Mem of Bap.Std.addr_size * Bap.Std.size
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
type typ = Bap.Std.Type.t
val bool_t : Bap.Std.typ
val reg8_t : Bap.Std.typ
val reg16_t : Bap.Std.typ
val reg32_t : Bap.Std.typ
val reg64_t : Bap.Std.typ
val reg128_t : Bap.Std.typ
val reg256_t : Bap.Std.typ
val mem32_t : Bap.Std.size -> Bap.Std.typ
val mem64_t : Bap.Std.size -> Bap.Std.typ
type var
module Var :
sig
type t = Bap.Std.var
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val create : ?tmp:bool -> string -> Bap.Std.typ -> Bap.Std.Var.t
val name : Bap.Std.Var.t -> string
val typ : Bap.Std.Var.t -> Bap.Std.typ
val is_tmp : Bap.Std.Var.t -> bool
module V1 :
sig
type r = string * int * Bap.Std.typ
val serialize : Bap.Std.Var.t -> Bap.Std.Var.V1.r
val deserialize : Bap.Std.Var.V1.r -> Bap.Std.Var.t
end
end
module Bil :
sig
module Types :
sig
type cast = UNSIGNED | SIGNED | HIGH | LOW
type binop =
PLUS
| MINUS
| TIMES
| DIVIDE
| SDIVIDE
| MOD
| SMOD
| LSHIFT
| ARSHIFT
| AND
| OR
| XOR
| EQ
| NEQ
| LT
| LE
| SLT
| SLE
type unop = NEG | NOT
type exp =
Load of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.endian * Bap.Std.size
| Store of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp * Bap.Std.endian * Bap.Std.size
| BinOp of Bap.Std.Bil.Types.binop * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| UnOp of Bap.Std.Bil.Types.unop * Bap.Std.Bil.Types.exp
| Var of Bap.Std.var
| Int of Bap.Std.word
| Cast of Bap.Std.Bil.Types.cast * Bap.Std.nat1 *
Bap.Std.Bil.Types.exp
| Let of Bap.Std.var * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| Unknown of string * Bap.Std.typ
| Ite of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.exp
| Extract of Bap.Std.nat1 * Bap.Std.nat1 *
Bap.Std.Bil.Types.exp
| Concat of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp
type stmt =
Move of Bap.Std.var * Bap.Std.Bil.Types.exp
| Jmp of Bap.Std.Bil.Types.exp
| While of Bap.Std.Bil.Types.exp *
Bap.Std.Bil.Types.stmt list
| If of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.stmt list *
Bap.Std.Bil.Types.stmt list
| CpuExn of int
end
type cast = Types.cast = UNSIGNED | SIGNED | HIGH | LOW
type binop =
Types.binop =
PLUS
| MINUS
| TIMES
| DIVIDE
| SDIVIDE
| MOD
| SMOD
| LSHIFT
| ARSHIFT
| AND
| OR
| XOR
| EQ
| NEQ
| LT
| LE
| SLT
| SLE
type unop = Types.unop = NEG | NOT
type exp =
Types.exp =
Load of exp * exp * endian * size
| Store of exp * exp * exp * endian * size
| BinOp of binop * exp * exp
| UnOp of unop * exp
| Var of var
| Int of word
| Cast of cast * nat1 * exp
| Let of var * exp * exp
| Unknown of string * typ
| Ite of exp * exp * exp
| Extract of nat1 * nat1 * exp
| Concat of exp * exp
type stmt =
Types.stmt =
Move of var * exp
| Jmp of exp
| While of exp * stmt list
| If of exp * stmt list * stmt list
| CpuExn of int
type t = stmt list
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
module Infix :
sig
val ( := ) : Bap.Std.var -> exp -> stmt
val ( + ) : exp -> exp -> exp
val ( - ) : exp -> exp -> exp
val ( * ) : exp -> exp -> exp
val ( / ) : exp -> exp -> exp
val ( /$ ) : exp -> exp -> exp
val ( mod ) : exp -> exp -> exp
val ( %$ ) : exp -> exp -> exp
val ( lsl ) : exp -> exp -> exp
val ( lsr ) : exp -> exp -> exp
val ( asr ) : exp -> exp -> exp
val ( land ) : exp -> exp -> exp
val ( lor ) : exp -> exp -> exp
val ( lxor ) : exp -> exp -> exp
val lnot : exp -> exp
val ( = ) : exp -> exp -> exp
val ( <> ) : exp -> exp -> exp
val ( < ) : exp -> exp -> exp
val ( > ) : exp -> exp -> exp
val ( <= ) : exp -> exp -> exp
val ( >= ) : exp -> exp -> exp
val ( <$ ) : exp -> exp -> exp
val ( >$ ) : exp -> exp -> exp
val ( <=$ ) : exp -> exp -> exp
val ( >=$ ) : exp -> exp -> exp
val ( ^ ) : exp -> exp -> exp
end
val ( := ) : var -> exp -> stmt
val ( + ) : exp -> exp -> exp
val ( - ) : exp -> exp -> exp
val ( * ) : exp -> exp -> exp
val ( / ) : exp -> exp -> exp
val ( /$ ) : exp -> exp -> exp
val ( mod ) : exp -> exp -> exp
val ( %$ ) : exp -> exp -> exp
val ( lsl ) : exp -> exp -> exp
val ( lsr ) : exp -> exp -> exp
val ( asr ) : exp -> exp -> exp
val ( land ) : exp -> exp -> exp
val ( lor ) : exp -> exp -> exp
val ( lxor ) : exp -> exp -> exp
val lnot : exp -> exp
val ( = ) : exp -> exp -> exp
val ( <> ) : exp -> exp -> exp
val ( < ) : exp -> exp -> exp
val ( > ) : exp -> exp -> exp
val ( <= ) : exp -> exp -> exp
val ( >= ) : exp -> exp -> exp
val ( <$ ) : exp -> exp -> exp
val ( >$ ) : exp -> exp -> exp
val ( <=$ ) : exp -> exp -> exp
val ( >=$ ) : exp -> exp -> exp
val ( ^ ) : exp -> exp -> exp
val move : Bap.Std.var -> exp -> stmt
val jmp : exp -> stmt
val special : string -> stmt
val while_ : exp -> stmt list -> stmt
val if_ : exp -> stmt list -> stmt list -> stmt
val cpuexn : int -> stmt
val unsigned : cast
val signed : cast
val high : cast
val low : cast
val plus : binop
val minus : binop
val times : binop
val divide : binop
val sdivide : binop
val modulo : binop
val smodulo : binop
val lshift : binop
val rshift : binop
val arshift : binop
val bit_and : binop
val bit_or : binop
val bit_xor : binop
val eq : binop
val neq : binop
val lt : binop
val le : binop
val slt : binop
val sle : binop
val neg : unop
val not : unop
val load :
mem:exp -> addr:exp -> Bap.Std.endian -> Bap.Std.size -> exp
val store :
mem:exp ->
addr:exp -> exp -> Bap.Std.endian -> Bap.Std.size -> exp
val binop : binop -> exp -> exp -> exp
val unop : unop -> exp -> exp
val var : Bap.Std.var -> exp
val int : Bap.Std.Bitvector.t -> exp
val cast : cast -> Bap.Std.nat1 -> exp -> exp
val let_ : Bap.Std.var -> exp -> exp -> exp
val unknown : string -> Bap.Std.typ -> exp
val ite : if_:exp -> then_:exp -> else_:exp -> exp
val extract : hi:Bap.Std.nat1 -> lo:Bap.Std.nat1 -> exp -> exp
val concat : exp -> exp -> exp
class state :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
end
class ['a] visitor :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method enter_binop : binop -> exp -> exp -> 'a -> 'a
method enter_cast : cast -> Bap.Std.nat1 -> exp -> 'a -> 'a
method enter_concat : exp -> exp -> 'a -> 'a
method enter_cpuexn : int -> 'a -> 'a
method enter_exp : exp -> 'a -> 'a
method enter_extract :
hi:Bap.Std.nat1 -> lo:Bap.Std.nat1 -> exp -> 'a -> 'a
method enter_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a -> 'a
method enter_int : Bap.Std.word -> 'a -> 'a
method enter_ite : cond:exp -> yes:exp -> no:exp -> 'a -> 'a
method enter_jmp : exp -> 'a -> 'a
method enter_let :
Bap.Std.var -> exp:exp -> body:exp -> 'a -> 'a
method enter_load :
mem:exp ->
addr:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method enter_move : Bap.Std.var -> exp -> 'a -> 'a
method enter_special : string -> 'a -> 'a
method enter_stmt : stmt -> 'a -> 'a
method enter_store :
mem:exp ->
addr:exp ->
exp:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method enter_unknown : string -> Bap.Std.typ -> 'a -> 'a
method enter_unop : unop -> exp -> 'a -> 'a
method enter_var : Bap.Std.var -> 'a -> 'a
method enter_while : cond:exp -> stmt list -> 'a -> 'a
method leave_binop : binop -> exp -> exp -> 'a -> 'a
method leave_cast : cast -> Bap.Std.nat1 -> exp -> 'a -> 'a
method leave_concat : exp -> exp -> 'a -> 'a
method leave_cpuexn : int -> 'a -> 'a
method leave_exp : exp -> 'a -> 'a
method leave_extract :
hi:Bap.Std.nat1 -> lo:Bap.Std.nat1 -> exp -> 'a -> 'a
method leave_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a -> 'a
method leave_int : Bap.Std.word -> 'a -> 'a
method leave_ite : cond:exp -> yes:exp -> no:exp -> 'a -> 'a
method leave_jmp : exp -> 'a -> 'a
method leave_let :
Bap.Std.var -> exp:exp -> body:exp -> 'a -> 'a
method leave_load :
mem:exp ->
addr:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method leave_move : Bap.Std.var -> exp -> 'a -> 'a
method leave_special : string -> 'a -> 'a
method leave_stmt : stmt -> 'a -> 'a
method leave_store :
mem:exp ->
addr:exp ->
exp:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method leave_unknown : string -> Bap.Std.typ -> 'a -> 'a
method leave_unop : unop -> exp -> 'a -> 'a
method leave_var : Bap.Std.var -> 'a -> 'a
method leave_while : cond:exp -> stmt list -> 'a -> 'a
method run : stmt list -> 'a -> 'a
method visit_binop : binop -> exp -> exp -> 'a -> 'a
method visit_cast : cast -> Bap.Std.nat1 -> exp -> 'a -> 'a
method visit_concat : exp -> exp -> 'a -> 'a
method visit_cpuexn : int -> 'a -> 'a
method visit_exp : exp -> 'a -> 'a
method visit_extract :
hi:Bap.Std.nat1 -> lo:Bap.Std.nat1 -> exp -> 'a -> 'a
method visit_if :
cond:exp -> yes:stmt list -> no:stmt list -> 'a -> 'a
method visit_int : Bap.Std.word -> 'a -> 'a
method visit_ite : cond:exp -> yes:exp -> no:exp -> 'a -> 'a
method visit_jmp : exp -> 'a -> 'a
method visit_let :
Bap.Std.var -> exp:exp -> body:exp -> 'a -> 'a
method visit_load :
mem:exp ->
addr:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method visit_move : Bap.Std.var -> exp -> 'a -> 'a
method visit_special : string -> 'a -> 'a
method visit_stmt : stmt -> 'a -> 'a
method visit_store :
mem:exp ->
addr:exp ->
exp:exp -> Bap.Std.endian -> Bap.Std.size -> 'a -> 'a
method visit_unknown : string -> Bap.Std.typ -> 'a -> 'a
method visit_unop : unop -> exp -> 'a -> 'a
method visit_var : Bap.Std.var -> 'a -> 'a
method visit_while : cond:exp -> stmt list -> 'a -> 'a
end
class ['a] finder :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method enter_binop :
binop ->
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_cast :
cast ->
nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_concat :
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_exp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_extract :
hi:nat1 ->
lo:nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_if :
cond:exp ->
yes:stmt list ->
no:stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_ite :
cond:exp ->
yes:exp ->
no:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_let :
var ->
exp:exp ->
body:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_load :
mem:exp ->
addr:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_special :
string ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_stmt :
stmt ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_store :
mem:exp ->
addr:exp ->
exp:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unknown :
string ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_unop :
unop ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method enter_while :
cond:exp ->
stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method find : stmt list -> 'a option
method leave_binop :
binop ->
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_cast :
cast ->
nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_concat :
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_exp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_extract :
hi:nat1 ->
lo:nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_if :
cond:exp ->
yes:stmt list ->
no:stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_ite :
cond:exp ->
yes:exp ->
no:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_let :
var ->
exp:exp ->
body:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_load :
mem:exp ->
addr:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_special :
string ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_stmt :
stmt ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_store :
mem:exp ->
addr:exp ->
exp:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unknown :
string ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_unop :
unop ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method leave_while :
cond:exp ->
stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method run :
stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_binop :
binop ->
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_cast :
cast ->
nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_concat :
exp ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_cpuexn :
int ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_exp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_extract :
hi:nat1 ->
lo:nat1 ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_if :
cond:exp ->
yes:stmt list ->
no:stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_int :
word ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_ite :
cond:exp ->
yes:exp ->
no:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_jmp :
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_let :
var ->
exp:exp ->
body:exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_load :
mem:exp ->
addr:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_move :
var ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_special :
string ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_stmt :
stmt ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_store :
mem:exp ->
addr:exp ->
exp:exp ->
endian ->
size ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unknown :
string ->
typ ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_unop :
unop ->
exp ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_var :
var ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
method visit_while :
cond:exp ->
stmt list ->
'a option Core_kernel.Std.return ->
'a option Core_kernel.Std.return
end
class mapper :
object
val exps_stack : exp list
val in_jmp : bool
val in_loop : bool
val in_move : bool
val preds : stmt list
val stmts_stack : stmt list
val succs : stmt list
val under_condition : bool
method map_binop : binop -> exp -> exp -> exp
method map_cast : cast -> Bap.Std.nat1 -> exp -> exp
method map_concat : exp -> exp -> exp
method map_cpuexn : int -> stmt list
method map_exp : exp -> exp
method map_extract :
hi:Bap.Std.nat1 -> lo:Bap.Std.nat1 -> exp -> exp
method map_if :
cond:exp -> yes:stmt list -> no:stmt list -> stmt list
method map_int : Bap.Std.word -> exp
method map_ite : cond:exp -> yes:exp -> no:exp -> exp
method map_jmp : exp -> stmt list
method map_let : Bap.Std.var -> exp:exp -> body:exp -> exp
method map_load :
mem:exp -> addr:exp -> Bap.Std.endian -> Bap.Std.size -> exp
method map_move : Bap.Std.var -> exp -> stmt list
method map_special : string -> stmt list
method map_stmt : stmt -> stmt list
method map_store :
mem:exp ->
addr:exp -> exp:exp -> Bap.Std.endian -> Bap.Std.size -> exp
method map_sym : Bap.Std.var -> Bap.Std.var
method map_unknown : string -> Bap.Std.typ -> exp
method map_unop : unop -> exp -> exp
method map_var : Bap.Std.var -> exp
method map_while : cond:exp -> stmt list -> stmt list
method run : stmt list -> stmt list
end
val find_map : 'a #Bap.Std.Bil.finder -> stmt list -> 'a option
val find : unit #Bap.Std.Bil.finder -> stmt list -> bool
val iter : unit #Bap.Std.Bil.visitor -> stmt list -> unit
val fold : 'a #Bap.Std.Bil.visitor -> init:'a -> stmt list -> 'a
val map : #Bap.Std.Bil.mapper -> stmt list -> stmt list
val is_referenced : Bap.Std.var -> stmt list -> bool
val is_assigned : ?strict:bool -> Bap.Std.var -> stmt list -> bool
val prune_unreferenced : stmt list -> stmt list
val normalize_negatives : stmt list -> stmt list
val substitute : exp -> exp -> stmt list -> stmt list
val substitute_var : Bap.Std.var -> exp -> stmt list -> stmt list
val fold_consts : stmt list -> stmt list
class constant_folder : mapper
val fixpoint : (stmt list -> stmt list) -> stmt list -> stmt list
module Trie :
sig
type normalized_bil
val normalize :
?subst:(exp * exp) list ->
stmt list -> Bap.Std.Bil.Trie.normalized_bil
module Normalized :
sig
type 'a t
type key = normalized_bil
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
type 'a t
type key = stmt list
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
module Exp :
sig
type t = Bap.Std.Bil.exp
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val pp_adt : Bap.Std.Exp.t Bap.Std.printer
end
module Stmt :
sig
type t = Bap.Std.Bil.stmt
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val pp_adt : Bap.Std.Stmt.t Bap.Std.printer
end
module Arch :
sig
type x86 = [ `x86 | `x86_64 ]
type arm =
[ `arm
| `armeb
| `armv4
| `armv4t
| `armv5
| `armv6
| `armv7
| `thumb
| `thumbeb ]
type aarch64 = [ `aarch64 | `aarch64_be ]
type ppc = [ `ppc | `ppc64 | `ppc64le ]
type mips = [ `mips | `mips64 | `mips64el | `mipsel ]
type sparc = [ `sparc | `sparcv9 ]
type nvptx = [ `nvptx | `nvptx64 ]
type hexagon = [ `hexagon ]
type r600 = [ `r600 ]
type systemz = [ `systemz ]
type xcore = [ `xcore ]
type t =
[ `aarch64
| `aarch64_be
| `arm
| `armeb
| `armv4
| `armv4t
| `armv5
| `armv6
| `armv7
| `hexagon
| `mips
| `mips64
| `mips64el
| `mipsel
| `nvptx
| `nvptx64
| `ppc
| `ppc64
| `ppc64le
| `r600
| `sparc
| `sparcv9
| `systemz
| `thumb
| `thumbeb
| `x86
| `x86_64
| `xcore ]
val of_string : string -> Bap.Std.Arch.t option
val addr_size : Bap.Std.Arch.t -> Bap.Std.addr_size
val endian : Bap.Std.Arch.t -> Bap.Std.endian
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
type arch = Bap.Std.Arch.t
module Value :
sig
type t
type 'a tag
module type S =
sig
type t
val pp : Format.formatter -> Bap.Std.Value.S.t -> unit
end
type void
type literal =
(Bap.Std.Value.void, Bap.Std.Value.void, Bap.Std.Value.void)
Pervasives.format
type typeid
val create : 'a Bap.Std.Value.tag -> 'a -> Bap.Std.Value.t
val is : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> bool
val get : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a option
val get_exn : 'a Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a
val tagname : Bap.Std.Value.t -> string
module Tag :
sig
type 'a t = 'a Bap.Std.Value.tag
val register :
name:Bap.Std.Value.literal ->
uuid:Bap.Std.Value.literal ->
(module Bap.Std.Value.S with type t = 'a) ->
'a Bap.Std.Value.tag
val to_string : 'a Bap.Std.Value.Tag.t -> string
end
module Typeid :
sig
type t = typeid
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
type 'a tag = 'a Bap.Std.Value.tag
type color =
[ `black
| `blue
| `cyan
| `green
| `magenta
| `red
| `white
| `yellow ]
val color : Bap.Std.color Bap.Std.tag
val comment : string Bap.Std.tag
val python : string Bap.Std.tag
val shell : string Bap.Std.tag
val mark : unit Bap.Std.tag
val weight : float Bap.Std.tag
val target_addr : Bap.Std.addr Bap.Std.tag
val target_name : string Bap.Std.tag
val subroutine_name : string Bap.Std.tag
val subroutine_addr : Bap.Std.addr Bap.Std.tag
val filename : string Bap.Std.tag
module Dict :
sig
type t
val empty : Bap.Std.Dict.t
val is_empty : Bap.Std.Dict.t -> bool
val set : Bap.Std.Dict.t -> 'a Bap.Std.tag -> 'a -> Bap.Std.Dict.t
val mem : Bap.Std.Dict.t -> 'a Bap.Std.tag -> bool
val find : Bap.Std.Dict.t -> 'a Bap.Std.tag -> 'a option
val add :
Bap.Std.Dict.t ->
'a Bap.Std.tag -> 'a -> [ `Duplicate | `Ok of Bap.Std.Dict.t ]
val change :
Bap.Std.Dict.t ->
'a Bap.Std.tag -> ('a option -> 'a option) -> Bap.Std.Dict.t
val remove : Bap.Std.Dict.t -> 'a Bap.Std.tag -> Bap.Std.Dict.t
val data :
Bap.Std.Dict.t -> Bap.Std.Value.t Core_kernel.Std.Sequence.t
end
module Seq :
sig
type 'a t = 'a Core_kernel.Std.Sequence.t
type 'a sequence = 'a t
val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
val length : 'a t -> int
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
end
val bind : 'a t -> ('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
val empty : 'a t
val next : 'a t -> ('a * 'a t) option
module Step :
sig
type ('a, 's) t =
('a, 's) Core_kernel.Sequence.Step.t =
Done
| Skip of 's
| Yield of 'a * 's
end
val unfold_step : init:'s -> f:('s -> ('a, 's) Step.t) -> 'a t
val unfold : init:'s -> f:('s -> ('a * 's) option) -> 'a t
val unfold_with :
'a t -> init:'s -> f:('s -> 'a -> ('b, 's) Step.t) -> 'b t
val nth : 'a t -> int -> 'a option
val nth_exn : 'a t -> int -> 'a
val mapi : 'a t -> f:(int -> 'a -> 'b) -> 'b t
val filteri : 'a t -> f:(int -> 'a -> bool) -> 'a t
val merge : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> 'a t
val hd : 'a t -> 'a option
val hd_exn : 'a t -> 'a
val tl : 'a t -> 'a t option
val tl_eagerly_exn : 'a t -> 'a t
val findi : 'a t -> f:(int -> 'a -> bool) -> (int * 'a) option
val find_exn : 'a t -> f:('a -> bool) -> 'a
val append : 'a t -> 'a t -> 'a t
val concat : 'a t t -> 'a t
val concat_map : 'a t -> f:('a -> 'b t) -> 'b t
val concat_mapi : 'a t -> f:(int -> 'a -> 'b t) -> 'b t
val zip : 'a t -> 'b t -> ('a * 'b) t
val zip_full :
'a t ->
'b t -> [ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] t
val iteri : 'a t -> f:(int -> 'a -> unit) -> unit
val foldi : 'a t -> f:(int -> 'b -> 'a -> 'b) -> init:'b -> 'b
val reduce_exn : 'a t -> f:('a -> 'a -> 'a) -> 'a
val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a option
val find_consecutive_duplicate :
'a t -> equal:('a -> 'a -> bool) -> ('a * 'a) option
val remove_consecutive_duplicates :
'a t -> equal:('a -> 'a -> bool) -> 'a t
val range :
?stride:int ->
?start:[ `exclusive | `inclusive ] ->
?stop:[ `exclusive | `inclusive ] -> int -> int -> int t
val init : int -> f:(int -> 'a) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi : 'a t -> f:(int -> 'a -> 'b option) -> 'b t
val filter_opt : 'a option t -> 'a t
val sub : 'a t -> pos:int -> len:int -> 'a t
val take : 'a t -> int -> 'a t
val drop : 'a t -> int -> 'a t
val drop_eagerly : 'a t -> int -> 'a t
val take_while : 'a t -> f:('a -> bool) -> 'a t
val drop_while : 'a t -> f:('a -> bool) -> 'a t
val drop_while_option :
'a t -> f:('a -> bool) -> ('a * 'a t) option
val split_n_eagerly : 'a t -> int -> 'a t * 'a t
val shift_right : 'a t -> 'a -> 'a t
val shift_right_with_list : 'a t -> 'a list -> 'a t
val shift_left : 'a t -> int -> 'a t
module Infix : sig val ( @ ) : 'a t -> 'a t -> 'a t end
val cartesian_product : 'a t -> 'b t -> ('a * 'b) t
val intersperse : 'a t -> sep:'a -> 'a t
val cycle : 'a t -> 'a t
val repeat : 'a -> 'a t
val singleton : 'a -> 'a t
val delayed_fold :
'a t ->
init:'s ->
f:('s -> 'a -> k:('s -> 'r) -> 'r) -> finish:('s -> 'r) -> 'r
val to_list : 'a t -> 'a list
val to_list_rev : 'a t -> 'a list
val of_list : 'a list -> 'a t
val memoize : 'a t -> 'a t
val force_eagerly : 'a t -> 'a t
val bounded_length :
'a t -> at_most:int -> [ `Greater | `Is of int ]
val length_is_bounded_by : ?min:int -> ?max:int -> 'a t -> bool
module Generator :
sig
type ('a, 'd) t = ('a, 'd) Core_kernel.Sequence.Generator.t
val ( >>= ) : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
module Monad_infix :
sig
val ( >>= ) :
('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
val ( >>| ) : ('a, 'd) t -> ('a -> 'b) -> ('b, 'd) t
end
val bind : ('a, 'd) t -> ('a -> ('b, 'd) t) -> ('b, 'd) t
val return : 'a -> ('a, 'b) t
val map : ('a, 'd) t -> f:('a -> 'b) -> ('b, 'd) t
val join : (('a, 'd) t, 'd) t -> ('a, 'd) t
val ignore : ('a, 'd) t -> (unit, 'd) t
val all : ('a, 'd) t list -> ('a list, 'd) t
val all_ignore : (unit, 'd) t list -> (unit, 'd) t
val yield : 'elt -> (unit, 'elt) t
val run : (unit, 'elt) t -> 'elt sequence
end
val of_array : 'a array -> 'a Bap.Std.Seq.t
val cons : 'a -> 'a Bap.Std.Seq.t -> 'a Bap.Std.Seq.t
val is_empty : 'a Bap.Std.Seq.t -> bool
end
type 'a seq = 'a Bap.Std.Seq.t
val ( ^:: ) : 'a -> 'a Bap.Std.seq -> 'a Bap.Std.seq
type 'a vector
module Vector :
sig
type 'a t = 'a Bap.Std.vector
val create : ?capacity:int -> 'a -> 'a Bap.Std.Vector.t
val append : 'a Bap.Std.Vector.t -> 'a -> unit
val nth : 'a Bap.Std.Vector.t -> int -> 'a option
val get : 'a Bap.Std.Vector.t -> int -> 'a
val set : 'a Bap.Std.Vector.t -> int -> 'a -> unit
val map_to_array : 'a Bap.Std.Vector.t -> f:('a -> 'b) -> 'b array
val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
module Config : sig val pkg_version : string end
type bil = Bap.Std.Bil.t
type binop = Bap.Std.Bil.binop
type cast = Bap.Std.Bil.cast
type exp = Bap.Std.Exp.t
type stmt = Bap.Std.Stmt.t
type unop = Bap.Std.Bil.unop
type value = Bap.Std.Value.t
type dict = Bap.Std.Dict.t
type image
type mem
type 'a table
type 'a memmap
module type Memory_iterators =
sig
type t
type 'a m
val fold :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
init:'b ->
f:(Bap.Std.word -> 'b -> 'b Bap.Std.Memory_iterators.m) ->
'b Bap.Std.Memory_iterators.m
val iter :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
unit Bap.Std.Memory_iterators.m
val foldi :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
init:'b ->
f:(Bap.Std.addr ->
Bap.Std.word -> 'b -> 'b Bap.Std.Memory_iterators.m) ->
'b Bap.Std.Memory_iterators.m
val iteri :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
unit Bap.Std.Memory_iterators.m
val exists :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
bool Bap.Std.Memory_iterators.m
val for_all :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
bool Bap.Std.Memory_iterators.m
val count :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
int Bap.Std.Memory_iterators.m
val find_if :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
Bap.Std.word option Bap.Std.Memory_iterators.m
val find_map :
?word_size:Bap.Std.size ->
Bap.Std.Memory_iterators.t ->
f:(Bap.Std.addr ->
Bap.Std.word -> 'a option Bap.Std.Memory_iterators.m) ->
'a option Bap.Std.Memory_iterators.m
end
module Memory :
sig
type t = Bap.Std.mem
val create :
?pos:int ->
?len:int ->
Bap.Std.endian ->
Bap.Std.addr ->
Core_kernel.Std.Bigstring.t ->
Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val of_file :
Bap.Std.endian ->
Bap.Std.addr ->
string -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val view :
?word_size:Bap.Std.size ->
?from:Bap.Std.addr ->
?words:int ->
Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val range :
Bap.Std.Memory.t ->
Bap.Std.addr ->
Bap.Std.addr -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val merge :
Bap.Std.Memory.t ->
Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
val first_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
val last_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
val endian : Bap.Std.Memory.t -> Bap.Std.endian
val get :
?disp:int ->
?index:int ->
?scale:Bap.Std.size ->
?addr:Bap.Std.addr ->
Bap.Std.Memory.t -> Bap.Std.word Core_kernel.Std.Or_error.t
val ( ^ ) :
Bap.Std.Memory.t ->
Bap.Std.addr -> Bap.Std.word Core_kernel.Std.Or_error.t
val ( ^! ) : Bap.Std.Memory.t -> Bap.Std.addr -> Bap.Std.word
val max_addr : Bap.Std.Memory.t -> Bap.Std.addr
val min_addr : Bap.Std.Memory.t -> Bap.Std.addr
val length : Bap.Std.Memory.t -> int
val contains : Bap.Std.Memory.t -> Bap.Std.addr -> bool
val compare_with :
Bap.Std.Memory.t ->
Bap.Std.addr ->
[ `addr_is_above | `addr_is_below | `addr_is_inside ]
module Input :
sig
type 'a reader =
Bap.Std.Memory.t ->
pos_ref:Bap.Std.addr Pervasives.ref ->
'a Core_kernel.Std.Or_error.t
val word :
word_size:Bap.Std.size ->
Bap.Std.word Bap.Std.Memory.Input.reader
val int8 : Bap.Std.word Bap.Std.Memory.Input.reader
val uint8 : Bap.Std.word Bap.Std.Memory.Input.reader
val int16 : Bap.Std.word Bap.Std.Memory.Input.reader
val uint16 : Bap.Std.word Bap.Std.Memory.Input.reader
val int32 : Bap.Std.word Bap.Std.Memory.Input.reader
val int64 : Bap.Std.word Bap.Std.Memory.Input.reader
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val hexdump : Bap.Std.Memory.t -> string
type 'a m = 'a
val fold :
?word_size:size -> t -> init:'b -> f:(word -> 'b -> 'b m) -> 'b m
val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b m) -> 'b m
val iteri :
?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
val exists :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val for_all :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val count :
?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
val find_if :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> word option m
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option m) -> 'a option m
module With_error :
sig
type 'a m = 'a Core_kernel.Std.Or_error.t
val fold :
?word_size:size ->
t -> init:'b -> f:(word -> 'b -> 'b m) -> 'b m
val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b m) -> 'b m
val iteri :
?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
val exists :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val for_all :
?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
val count :
?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
val find_if :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> word option m
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option m) -> 'a option m
end
module Make_iterators :
functor (M : Core_kernel.Std.Monad.S) ->
sig
type 'a m = 'a M.t
val fold :
?word_size:size ->
t -> init:'b -> f:(word -> 'b -> 'b m) -> 'b m
val iter :
?word_size:size -> t -> f:(word -> unit m) -> unit m
val foldi :
?word_size:size ->
t -> init:'b -> f:(addr -> word -> 'b -> 'b m) -> 'b m
val iteri :
?word_size:size ->
t -> f:(addr -> word -> unit m) -> unit m
val exists :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> bool m
val for_all :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> bool m
val count :
?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
val find_if :
?word_size:size ->
t -> f:(addr -> word -> bool m) -> word option m
val find_map :
?word_size:size ->
t -> f:(addr -> word -> 'a option m) -> 'a option m
end
val to_buffer : Bap.Std.Memory.t -> Core_kernel.Std.Bigsubstring.t
module Trie :
sig
module R8 :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module R16 :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module R32 :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
module R64 :
sig
type 'a t
type key = t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
end
module Table :
sig
type 'a t = 'a Bap.Std.table
type 'a hashable = 'a Core_kernel.Std.Hashtbl.Hashable.t
val empty : 'a Bap.Std.Table.t
val singleton : Bap.Std.mem -> 'a -> 'a Bap.Std.Table.t
val add :
'a Bap.Std.Table.t ->
Bap.Std.mem ->
'a -> 'a Bap.Std.Table.t Core_kernel.Std.Or_error.t
val remove :
'a Bap.Std.Table.t -> Bap.Std.mem -> 'a Bap.Std.Table.t
val change :
'a Bap.Std.Table.t ->
Bap.Std.mem ->
f:((Bap.Std.mem * 'a) Bap.Std.seq ->
[ `ignore
| `rebind of Bap.Std.mem * 'a
| `remove
| `update of Bap.Std.mem * 'a -> 'a ]) ->
'a Bap.Std.Table.t
val length : 'a Bap.Std.Table.t -> int
val find : 'a Bap.Std.Table.t -> Bap.Std.mem -> 'a option
val find_addr :
'a Bap.Std.Table.t -> Bap.Std.addr -> (Bap.Std.mem * 'a) option
val intersections :
'a Bap.Std.Table.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val fold_intersections :
'a Bap.Std.Table.t ->
Bap.Std.mem -> init:'b -> f:(Bap.Std.mem -> 'a -> 'b -> 'b) -> 'b
val has_intersections : 'a Bap.Std.Table.t -> Bap.Std.mem -> bool
val mem : 'a Bap.Std.Table.t -> Bap.Std.mem -> bool
val next :
'a Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
val prev :
'a Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
val min : 'a Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
val max : 'a Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
type ('a, 'm) r
val many : ('a, 'a Bap.Std.seq) Bap.Std.Table.r
val at_least_one : ('a, 'a * 'a Bap.Std.seq) Bap.Std.Table.r
val one : ('a, 'a) Bap.Std.Table.r
val maybe_one : ('a, 'a option) Bap.Std.Table.r
val link :
one_to:('b, 'r) Bap.Std.Table.r ->
'a Bap.Std.Table.hashable ->
'a Bap.Std.Table.t -> 'b Bap.Std.Table.t -> 'a -> 'r
val rev_map :
one_to:(Bap.Std.mem, 'r) Bap.Std.Table.r ->
'a Bap.Std.Table.hashable ->
'a Bap.Std.Table.t -> ('a -> 'r) Core_kernel.Std.Or_error.t
type 'a ranged = ?start:Bap.Std.mem -> ?until:Bap.Std.mem -> 'a
val exists :
('a Bap.Std.Table.t -> f:('a -> bool) -> bool)
Bap.Std.Table.ranged
val for_all :
('a Bap.Std.Table.t -> f:('a -> bool) -> bool)
Bap.Std.Table.ranged
val count :
('a Bap.Std.Table.t -> f:('a -> bool) -> int)
Bap.Std.Table.ranged
val find_if :
('a Bap.Std.Table.t -> f:('a -> bool) -> 'a option)
Bap.Std.Table.ranged
val find_map :
('a Bap.Std.Table.t -> f:('a -> 'b option) -> 'b option)
Bap.Std.Table.ranged
val fold :
('a Bap.Std.Table.t -> init:'b -> f:('a -> 'b -> 'b) -> 'b)
Bap.Std.Table.ranged
val iter :
('a Bap.Std.Table.t -> f:('a -> unit) -> unit)
Bap.Std.Table.ranged
val find_mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b option)
Bap.Std.Table.ranged
val foldi :
('a Bap.Std.Table.t ->
init:'b -> f:(Bap.Std.mem -> 'a -> 'b -> 'b) -> 'b)
Bap.Std.Table.ranged
val iteri :
('a Bap.Std.Table.t -> f:(Bap.Std.mem -> 'a -> unit) -> unit)
Bap.Std.Table.ranged
val map :
('a Bap.Std.Table.t -> f:('a -> 'b) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter :
('a Bap.Std.Table.t -> f:('a -> bool) -> 'a Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter_map :
('a Bap.Std.Table.t -> f:('a -> 'b option) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val filteri :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> bool) -> 'a Bap.Std.Table.t)
Bap.Std.Table.ranged
val filter_mapi :
('a Bap.Std.Table.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b Bap.Std.Table.t)
Bap.Std.Table.ranged
val to_sequence :
('a Bap.Std.Table.t ->
(Bap.Std.mem * 'a) Core_kernel.Std.Sequence.t)
Bap.Std.Table.ranged
val regions :
('a Bap.Std.Table.t -> Bap.Std.mem Bap.Std.seq)
Bap.Std.Table.ranged
val elements :
('a Bap.Std.Table.t -> 'a Bap.Std.seq) Bap.Std.Table.ranged
end
module Location : sig type t = { addr : Bap.Std.addr; len : int; } end
type location = Bap.Std.Location.t
module Backend :
sig
type perm =
R
| W
| X
| Or of Bap.Std.Backend.perm * Bap.Std.Backend.perm
module Section :
sig
type t = {
name : string;
perm : Bap.Std.Backend.perm;
off : int;
location : Bap.Std.location;
}
end
module Sym :
sig
type t = {
name : string;
is_function : bool;
is_debug : bool;
locations : Bap.Std.location * Bap.Std.location list;
}
end
module Region :
sig type t = { name : string; location : Bap.Std.location; } end
module Img :
sig
type t = {
arch : Bap.Std.arch;
entry : Bap.Std.addr;
sections :
Bap.Std.Backend.Section.t * Bap.Std.Backend.Section.t list;
symbols : Bap.Std.Backend.Sym.t list;
regions : Bap.Std.Backend.Region.t list;
}
end
type t =
Core_kernel.Std.Bigstring.t -> Bap.Std.Backend.Img.t option
end
module Image :
sig
type t = Bap.Std.image
type sec
type sym
type path = string
type result =
(Bap.Std.Image.t * Core_kernel.Std.Error.t list)
Core_kernel.Std.Or_error.t
val create :
?backend:string -> Bap.Std.Image.path -> Bap.Std.Image.result
val of_string : ?backend:string -> string -> Bap.Std.Image.result
val of_bigstring :
?backend:string ->
Core_kernel.Std.Bigstring.t -> Bap.Std.Image.result
val entry_point : Bap.Std.Image.t -> Bap.Std.addr
val filename : Bap.Std.Image.t -> string option
val arch : Bap.Std.Image.t -> Bap.Std.arch
val addr_size : Bap.Std.Image.t -> Bap.Std.addr_size
val endian : Bap.Std.Image.t -> Bap.Std.endian
val data : Bap.Std.Image.t -> Core_kernel.Std.Bigstring.t
val words :
Bap.Std.Image.t -> Bap.Std.size -> Bap.Std.word Bap.Std.table
val sections : Bap.Std.Image.t -> Bap.Std.Image.sec Bap.Std.table
val symbols : Bap.Std.Image.t -> Bap.Std.Image.sym Bap.Std.table
val section : Bap.Std.Image.sec Bap.Std.tag
val symbol : string Bap.Std.tag
val region : string Bap.Std.tag
val memory : Bap.Std.Image.t -> Bap.Std.value Bap.Std.memmap
val memory_of_section :
Bap.Std.Image.t -> Bap.Std.Image.sec -> Bap.Std.mem
val memory_of_symbol :
Bap.Std.Image.t ->
Bap.Std.Image.sym -> Bap.Std.mem * Bap.Std.mem Bap.Std.seq
val symbols_of_section :
Bap.Std.Image.t ->
Bap.Std.Image.sec -> Bap.Std.Image.sym Bap.Std.seq
val section_of_symbol :
Bap.Std.Image.t -> Bap.Std.Image.sym -> Bap.Std.Image.sec
module Sec :
sig
type t = Bap.Std.Image.sec
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val name : Bap.Std.Image.Sec.t -> string
val is_writable : Bap.Std.Image.Sec.t -> bool
val is_readable : Bap.Std.Image.Sec.t -> bool
val is_executable : Bap.Std.Image.Sec.t -> bool
end
module Sym :
sig
type t = Bap.Std.Image.sym
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val name : Bap.Std.Image.Sym.t -> string
val is_function : Bap.Std.Image.Sym.t -> bool
val is_debug : Bap.Std.Image.Sym.t -> bool
end
val register_backend :
name:string -> Bap.Std.Backend.t -> [ `Duplicate | `Ok ]
end
module Memmap :
sig
type 'a t = 'a Bap.Std.memmap
val empty : 'a Bap.Std.Memmap.t
val singleton : Bap.Std.mem -> 'a -> 'a Bap.Std.Memmap.t
val min_addr : 'a Bap.Std.Memmap.t -> Bap.Std.addr option
val max_addr : 'a Bap.Std.Memmap.t -> Bap.Std.addr option
val min_binding : 'a Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
val max_binding : 'a Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
val add :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a -> 'a Bap.Std.Memmap.t
val dominators :
'a Bap.Std.Memmap.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val intersections :
'a Bap.Std.Memmap.t ->
Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
val intersects : 'a Bap.Std.Memmap.t -> Bap.Std.mem -> bool
val dominates : 'a Bap.Std.Memmap.t -> Bap.Std.mem -> bool
val contains : 'a Bap.Std.Memmap.t -> Bap.Std.addr -> bool
val lookup :
'a Bap.Std.Memmap.t ->
Bap.Std.addr -> (Bap.Std.mem * 'a) Bap.Std.seq
val map :
'a Bap.Std.Memmap.t -> f:('a -> 'b) -> 'b Bap.Std.Memmap.t
val mapi :
'a Bap.Std.Memmap.t ->
f:(Bap.Std.mem -> 'a -> 'b) -> 'b Bap.Std.Memmap.t
val filter_map :
'a Bap.Std.Memmap.t -> f:('a -> 'b option) -> 'b Bap.Std.Memmap.t
val filter_mapi :
'a Bap.Std.Memmap.t ->
f:(Bap.Std.mem -> 'a -> 'b option) -> 'b Bap.Std.Memmap.t
val remove :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val remove_intersections :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val remove_dominators :
'a Bap.Std.Memmap.t -> Bap.Std.mem -> 'a Bap.Std.Memmap.t
val to_sequence :
'a Bap.Std.Memmap.t ->
(Bap.Std.mem * 'a) Core_kernel.Std.Sequence.t
val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
end
type disasm
type insn
type block
val disassemble :
?roots:Bap.Std.addr list ->
Bap.Std.arch -> Bap.Std.mem -> Bap.Std.disasm
val disassemble_image :
?roots:Bap.Std.addr list -> Bap.Std.image -> Bap.Std.disasm
val disassemble_file :
?roots:Bap.Std.addr list ->
string -> Bap.Std.disasm Core_kernel.Std.Or_error.t
val disassemble_file_exn :
?roots:Bap.Std.addr list -> string -> Bap.Std.disasm
val linear_sweep :
Bap.Std.arch ->
Bap.Std.mem ->
(Bap.Std.mem * Bap.Std.insn option) list Core_kernel.Std.Or_error.t
val linear_sweep_exn :
Bap.Std.arch ->
Bap.Std.mem -> (Bap.Std.mem * Bap.Std.insn option) list
module Disasm :
sig
type t = Bap.Std.disasm
val insns :
Bap.Std.Disasm.t -> (Bap.Std.mem * Bap.Std.insn) Bap.Std.seq
val blocks : Bap.Std.Disasm.t -> Bap.Std.block Bap.Std.table
val insn_at_mem :
Bap.Std.Disasm.t -> Bap.Std.mem -> Bap.Std.insn option
val insns_at_mem :
Bap.Std.Disasm.t ->
Bap.Std.mem -> (Bap.Std.mem * Bap.Std.insn) Bap.Std.seq
val mems_of_insn :
Bap.Std.Disasm.t -> Bap.Std.insn -> Bap.Std.mem Bap.Std.seq
val insn_at_addr :
Bap.Std.Disasm.t ->
Bap.Std.addr -> (Bap.Std.mem * Bap.Std.insn) option
val span : Bap.Std.Disasm.t -> Bap.Std.mem Bap.Std.seq
type error =
[ `Failed of Core_kernel.Std.Error.t
| `Failed_to_disasm of Bap.Std.mem
| `Failed_to_lift of
Bap.Std.mem * Bap.Std.insn * Core_kernel.Std.Error.t ]
module Error :
sig
val to_string : error -> string
val str : unit -> error -> string
val pps : unit -> error -> string
val ppo : out_channel -> error -> unit
val pp : Format.formatter -> error -> unit
end
val errors :
Bap.Std.Disasm.t ->
(Bap.Std.mem * Bap.Std.Disasm.error) Bap.Std.seq
val insn : Bap.Std.insn Bap.Std.tag
end
module Kind :
sig
type branch =
[ `Conditional_branch
| `Indirect_branch
| `Unconditional_branch ]
type affecting_control =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `Return
| `Terminator
| `Unconditional_branch ]
type having_side_effect = [ `May_load | `May_store ]
type t =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `May_load
| `May_store
| `Return
| `Terminator
| `Unconditional_branch ]
end
type reg
type imm
type fmm
type kind = Bap.Std.Kind.t
module Reg :
sig
type t = Bap.Std.reg
val code : Bap.Std.Reg.t -> int
val name : Bap.Std.Reg.t -> string
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Imm :
sig
type t = Bap.Std.imm
val to_word : Bap.Std.Imm.t -> width:int -> Bap.Std.word option
val to_int64 : Bap.Std.Imm.t -> int64
val to_int : Bap.Std.Imm.t -> int option
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Fmm :
sig
type t = Bap.Std.fmm
val to_float : Bap.Std.Fmm.t -> float
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Op :
sig
type t =
Reg of Bap.Std.reg
| Imm of Bap.Std.imm
| Fmm of Bap.Std.fmm
module Normalized :
sig
val compare : Bap.Std.Op.t -> Bap.Std.Op.t -> int
val hash : Bap.Std.Op.t -> int
val compare_ops :
Bap.Std.Op.t array -> Bap.Std.Op.t array -> int
end
val pp_adt : Format.formatter -> Bap.Std.Op.t -> unit
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
type op = Bap.Std.Op.t
class type abi =
object
method args : (string option * Bap.Std.exp) list
method choose : Bap.Std.abi -> int
method id : string list
method records : (string option * Bap.Std.exp) list list
method return_value : Bap.Std.exp option
method specific : bool
method vars : (string option * Bap.Std.exp) list
end
type abi_constructor =
?image:Bap.Std.image ->
?sym:string -> Bap.Std.mem -> Bap.Std.block -> Bap.Std.abi
module type CPU =
sig
val gpr : Bap.Std.Var.Set.t
val mem : Bap.Std.var
val pc : Bap.Std.var
val sp : Bap.Std.var
val zf : Bap.Std.var
val cf : Bap.Std.var
val vf : Bap.Std.var
val nf : Bap.Std.var
val addr_of_pc : Bap.Std.mem -> Bap.Std.addr
val is_reg : Bap.Std.var -> bool
val is_flag : Bap.Std.var -> bool
val is_sp : Bap.Std.var -> bool
val is_bp : Bap.Std.var -> bool
val is_pc : Bap.Std.var -> bool
val is_zf : Bap.Std.var -> bool
val is_cf : Bap.Std.var -> bool
val is_vf : Bap.Std.var -> bool
val is_nf : Bap.Std.var -> bool
val is_mem : Bap.Std.var -> bool
end
module type ABI =
sig
val create :
?merge:(Bap.Std.abi list -> Bap.Std.abi) ->
?image:Bap.Std.image ->
?sym:string -> Bap.Std.mem -> Bap.Std.block -> Bap.Std.abi
val merge : Bap.Std.abi list -> Bap.Std.abi
val merge_id : string list -> string list -> string list
class stub : abi
val to_string : Bap.Std.arch -> string list -> string
val register : Bap.Std.abi_constructor -> unit
end
type jump = [ `Cond | `Jump ]
type edge = [ `Cond | `Fall | `Jump ]
module type Block_accessors =
sig
type t
type insn
val addr : Bap.Std.Block_accessors.t -> Bap.Std.addr
val memory : Bap.Std.Block_accessors.t -> Bap.Std.mem
val leader :
Bap.Std.Block_accessors.t -> Bap.Std.Block_accessors.insn
val terminator :
Bap.Std.Block_accessors.t -> Bap.Std.Block_accessors.insn
val insns :
Bap.Std.Block_accessors.t ->
(Bap.Std.mem * Bap.Std.Block_accessors.insn) list
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
val hash : t -> int
val compare : t -> t -> int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
end
module type Block_traverse =
sig
type t
type dest =
[ `Block of Bap.Std.Block_traverse.t * Bap.Std.edge
| `Unresolved of Bap.Std.jump ]
val dests :
Bap.Std.Block_traverse.t ->
Bap.Std.Block_traverse.dest Bap.Std.seq
val succs :
Bap.Std.Block_traverse.t -> Bap.Std.Block_traverse.t Bap.Std.seq
val preds :
Bap.Std.Block_traverse.t -> Bap.Std.Block_traverse.t Bap.Std.seq
end
module Disasm_expert :
sig
module Basic :
sig
type pred =
[ `Barrier
| `Call
| `Conditional_branch
| `Indirect_branch
| `May_affect_control_flow
| `May_load
| `May_store
| `Return
| `Terminator
| `Unconditional_branch
| `Valid ]
type reg
type imm
type fmm
type (+'a, +'k) insn
type ('a, 'k) insns =
(Bap.Std.mem *
('a, 'k) Bap.Std.Disasm_expert.Basic.insn option)
list
type empty
type asm
type kinds
type full_insn =
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn
type ('a, 'k) t
type (+'a, +'k, 's, 'r) state
val create :
?debug_level:int ->
?cpu:string ->
backend:string ->
string ->
(Bap.Std.Disasm_expert.Basic.empty,
Bap.Std.Disasm_expert.Basic.empty)
Bap.Std.Disasm_expert.Basic.t Core_kernel.Std.Or_error.t
val store_asm :
('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
(Bap.Std.Disasm_expert.Basic.asm, 'k)
Bap.Std.Disasm_expert.Basic.t
val store_kinds :
('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.t
val run :
?stop_on:Bap.Std.Disasm_expert.Basic.pred list ->
?invalid:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem -> 's -> 'r) ->
?stopped:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r) ->
?hit:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem ->
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn -> 's -> 'r) ->
('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
return:('s -> 'r) -> init:'s -> Bap.Std.mem -> 'r
val insn_of_mem :
('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
Bap.Std.mem ->
(Bap.Std.mem *
(Bap.Std.Disasm_expert.Basic.asm,
Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.insn option *
[ `finished | `left of Bap.Std.mem ])
Core_kernel.Std.Or_error.t
val addr :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.addr
val preds :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.Disasm_expert.Basic.pred list
val with_preds :
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.Disasm_expert.Basic.pred list ->
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state
val insns :
('a, 'k, 'b, 'c) Bap.Std.Disasm_expert.Basic.state ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insns
val last :
('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
int -> ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
val memory :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem
val stop :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
val step :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
val jump :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
Bap.Std.mem -> 's -> 'r
val back :
('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
's -> 'r
module Insn :
sig
type ('a, 'k) t = ('a, 'k) Bap.Std.Disasm_expert.Basic.insn
val sexp_of_t :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
Core_kernel.Std.Sexp.t
val compare :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
val code :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
val name :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> string
val kinds :
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.Insn.t -> Bap.Std.Kind.t list
val is :
('a, Bap.Std.Disasm_expert.Basic.kinds)
Bap.Std.Disasm_expert.Basic.Insn.t ->
Bap.Std.Kind.t -> bool
val asm :
(Bap.Std.Disasm_expert.Basic.asm, 'k)
Bap.Std.Disasm_expert.Basic.Insn.t -> string
val ops :
('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
Bap.Std.op array
end
module Trie :
sig
type key
val key_of_first_insns :
('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
len:int -> Bap.Std.Disasm_expert.Basic.Trie.key option
module Normalized :
sig
type 'a t
type key = key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
type 'a t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
end
module Recursive :
sig
type t
type block
type lifter =
Bap.Std.mem ->
Bap.Std.Disasm_expert.Basic.full_insn ->
Bap.Std.bil Core_kernel.Std.Or_error.t
type maybe_insn =
Bap.Std.Disasm_expert.Basic.full_insn option *
Bap.Std.bil option
type decoded =
Bap.Std.mem * Bap.Std.Disasm_expert.Recursive.maybe_insn
type error =
[ `Failed_to_disasm of Bap.Std.mem
| `Failed_to_lift of
Bap.Std.mem * Bap.Std.Disasm_expert.Basic.full_insn *
Core_kernel.Std.Error.t ]
val run :
?backend:string ->
?lifter:Bap.Std.Disasm_expert.Recursive.lifter ->
?roots:Bap.Std.addr list ->
Bap.Std.arch ->
Bap.Std.mem ->
Bap.Std.Disasm_expert.Recursive.t Core_kernel.Std.Or_error.t
val blocks :
Bap.Std.Disasm_expert.Recursive.t ->
Bap.Std.Disasm_expert.Recursive.block Bap.Std.Table.t
val errors :
Bap.Std.Disasm_expert.Recursive.t ->
Bap.Std.Disasm_expert.Recursive.error list
module Block :
sig
type t = block
val addr : t -> addr
val memory : t -> mem
val leader : t -> maybe_insn
val terminator : t -> maybe_insn
val insns : t -> (mem * maybe_insn) list
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a
| `Right of 'a
| `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
val hash : t -> int
val compare : t -> t -> int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c ->
f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c,
('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) ->
('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove :
('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c ->
f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c,
('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) ->
('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove :
('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
type dest = [ `Block of t * edge | `Unresolved of jump ]
val dests : t -> dest seq
val succs : t -> t seq
val preds : t -> t seq
end
end
end
module Insn :
sig
type t = Bap.Std.insn
type op = Bap.Std.Op.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val name : Bap.Std.Insn.t -> string
val asm : Bap.Std.Insn.t -> string
val bil : Bap.Std.Insn.t -> Bap.Std.bil
val ops : Bap.Std.Insn.t -> Bap.Std.Insn.op array
val is_jump : Bap.Std.Insn.t -> bool
val is_conditional_jump : Bap.Std.Insn.t -> bool
val is_unconditional_jump : Bap.Std.Insn.t -> bool
val is_indirect_jump : Bap.Std.Insn.t -> bool
val is_call : Bap.Std.Insn.t -> bool
val is_return : Bap.Std.Insn.t -> bool
val may_affect_control_flow : Bap.Std.Insn.t -> bool
val has_side_effect : Bap.Std.Insn.t -> bool
val may_load : Bap.Std.Insn.t -> bool
val may_store : Bap.Std.Insn.t -> bool
val pp_adt : Bap.Std.Insn.t Bap.Std.printer
module Trie :
sig
type key
val key_of_insns : Bap.Std.Insn.t list -> Bap.Std.Insn.Trie.key
module Normalized :
sig
type 'a t
type key = key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
type 'a t
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change : 'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match : 'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end
val of_basic :
?bil:Bap.Std.bil ->
Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Insn.t
end
module Block :
sig
type t = Bap.Std.block
val addr : t -> addr
val memory : t -> mem
val leader : t -> insn
val terminator : t -> insn
val insns : t -> (mem * insn) list
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
val hash : t -> int
val compare : t -> t -> int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
type dest = [ `Block of t * edge | `Unresolved of jump ]
val dests : t -> dest seq
val succs : t -> t seq
val preds : t -> t seq
val dfs :
?order:[ `post | `pre ] ->
?next:(Bap.Std.Block.t -> Bap.Std.Block.t Bap.Std.seq) ->
?bound:Bap.Std.mem ->
Bap.Std.Block.t -> Bap.Std.Block.t Bap.Std.seq
module Cfg :
sig
module Block :
sig
type t
val addr : t -> addr
val memory : t -> mem
val leader : t -> insn
val terminator : t -> insn
val insns : t -> (mem * insn) list
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map :
'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t ->
f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal :
('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] -> 'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a
| `Right of 'a
| `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b ->
f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t ->
min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map :
t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b ->
Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
val hash : t -> int
val compare : t -> t -> int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c ->
f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c,
('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) ->
('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove :
('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable :
key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list
| `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key :
('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c ->
f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn :
('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c,
('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) ->
('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove :
('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace :
('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ ->
('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt :
'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace :
'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
end
module Imperative :
sig
type t
module V :
sig
type t = Block.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = Block.t
val create : label -> t
val label : t -> label
end
type vertex = V.t
module E :
sig
type t = Block.t * edge * Block.t
val compare : t -> t -> int
type vertex = vertex
val src : t -> vertex
val dst : t -> vertex
type label = edge
val create : vertex -> label -> vertex -> t
val label : t -> label
end
type edge = E.t
val is_directed : bool
val is_empty : t -> bool
val nb_vertex : t -> int
val nb_edges : t -> int
val out_degree : t -> vertex -> int
val in_degree : t -> vertex -> int
val mem_vertex : t -> vertex -> bool
val mem_edge : t -> vertex -> vertex -> bool
val mem_edge_e : t -> edge -> bool
val find_edge : t -> vertex -> vertex -> edge
val find_all_edges : t -> vertex -> vertex -> edge list
val succ : t -> vertex -> vertex list
val pred : t -> vertex -> vertex list
val succ_e : t -> vertex -> edge list
val pred_e : t -> vertex -> edge list
val iter_vertex : (vertex -> unit) -> t -> unit
val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges : (vertex -> vertex -> unit) -> t -> unit
val fold_edges :
(vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (edge -> unit) -> t -> unit
val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
val map_vertex : (vertex -> vertex) -> t -> t
val iter_succ : (vertex -> unit) -> t -> vertex -> unit
val iter_pred : (vertex -> unit) -> t -> vertex -> unit
val fold_succ :
(vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val fold_pred :
(vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
val fold_succ_e :
(edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
val fold_pred_e :
(edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val create : ?size:int -> unit -> t
val clear : t -> unit
val copy : t -> t
val add_vertex : t -> vertex -> unit
val remove_vertex : t -> vertex -> unit
val add_edge : t -> vertex -> vertex -> unit
val add_edge_e : t -> edge -> unit
val remove_edge : t -> vertex -> vertex -> unit
val remove_edge_e : t -> edge -> unit
end
type t
module V :
sig
type t = Block.t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = Block.t
val create : label -> t
val label : t -> label
end
type vertex = V.t
module E :
sig
type t = Block.t * edge * Block.t
val compare : t -> t -> int
type vertex = vertex
val src : t -> vertex
val dst : t -> vertex
type label = edge
val create : vertex -> label -> vertex -> t
val label : t -> label
end
type edge = E.t
val is_directed : bool
val is_empty : t -> bool
val nb_vertex : t -> int
val nb_edges : t -> int
val out_degree : t -> vertex -> int
val in_degree : t -> vertex -> int
val mem_vertex : t -> vertex -> bool
val mem_edge : t -> vertex -> vertex -> bool
val mem_edge_e : t -> edge -> bool
val find_edge : t -> vertex -> vertex -> edge
val find_all_edges : t -> vertex -> vertex -> edge list
val succ : t -> vertex -> vertex list
val pred : t -> vertex -> vertex list
val succ_e : t -> vertex -> edge list
val pred_e : t -> vertex -> edge list
val iter_vertex : (vertex -> unit) -> t -> unit
val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges : (vertex -> vertex -> unit) -> t -> unit
val fold_edges :
(vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (edge -> unit) -> t -> unit
val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
val map_vertex : (vertex -> vertex) -> t -> t
val iter_succ : (vertex -> unit) -> t -> vertex -> unit
val iter_pred : (vertex -> unit) -> t -> vertex -> unit
val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val empty : t
val add_vertex : t -> vertex -> t
val remove_vertex : t -> vertex -> t
val add_edge : t -> vertex -> vertex -> t
val add_edge_e : t -> edge -> t
val remove_edge : t -> vertex -> vertex -> t
val remove_edge_e : t -> edge -> t
end
val to_graph :
?bound:Bap.Std.mem ->
Bap.Std.Block.t ->
Bap.Std.Block.Cfg.Block.t * Bap.Std.Block.Cfg.t
val to_imperative_graph :
?bound:Bap.Std.mem ->
Bap.Std.Block.t ->
Bap.Std.Block.Cfg.Block.t * Bap.Std.Block.Cfg.Imperative.t
end
module type Target =
sig
module CPU : CPU
module ABI : ABI
val lift :
Bap.Std.mem ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insn ->
Bap.Std.bil Core_kernel.Std.Or_error.t
end
val target_of_arch : Bap.Std.arch -> (module Bap.Std.Target)
module ARM :
sig
val lift :
Bap.Std.mem ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insn ->
Bap.Std.bil Core_kernel.Std.Or_error.t
module ABI :
sig
val create :
?merge:(abi list -> abi) ->
?image:image -> ?sym:string -> mem -> block -> abi
val merge : abi list -> abi
val merge_id : string list -> string list -> string list
class stub : abi
val to_string : arch -> string list -> string
val register : abi_constructor -> unit
class gnueabi :
?image:Bap.Std.image ->
?sym:string -> Bap.Std.mem -> Bap.Std.block -> abi
end
module CPU :
sig
val gpr : Var.Set.t
val mem : var
val addr_of_pc : mem -> addr
val is_reg : var -> bool
val is_flag : var -> bool
val is_sp : var -> bool
val is_bp : var -> bool
val is_pc : var -> bool
val is_zf : var -> bool
val is_cf : var -> bool
val is_vf : var -> bool
val is_nf : var -> bool
val is_mem : var -> bool
val spsr : Bap.Std.var
val cpsr : Bap.Std.var
val nf : Bap.Std.var
val zf : Bap.Std.var
val cf : Bap.Std.var
val vf : Bap.Std.var
val qf : Bap.Std.var
val ge : Bap.Std.var array
val itstate : Bap.Std.var
val lr : Bap.Std.var
val pc : Bap.Std.var
val sp : Bap.Std.var
val r0 : Bap.Std.var
val r1 : Bap.Std.var
val r2 : Bap.Std.var
val r3 : Bap.Std.var
val r4 : Bap.Std.var
val r5 : Bap.Std.var
val r6 : Bap.Std.var
val r7 : Bap.Std.var
val r8 : Bap.Std.var
val r9 : Bap.Std.var
val r10 : Bap.Std.var
val r11 : Bap.Std.var
val r12 : Bap.Std.var
end
module Insn :
sig
type move =
[ `ADCri
| `ADCrr
| `ADCrsi
| `ADCrsr
| `ADDri
| `ADDrr
| `ADDrsi
| `ADDrsr
| `ANDri
| `ANDrr
| `ANDrsi
| `ANDrsr
| `BICri
| `BICrr
| `BICrsi
| `BICrsr
| `CMNri
| `CMNzrr
| `CMNzrsi
| `CMNzrsr
| `CMPri
| `CMPrr
| `CMPrsi
| `CMPrsr
| `EORri
| `EORrr
| `EORrsi
| `EORrsr
| `MOVTi16
| `MOVi
| `MOVi16
| `MOVr
| `MOVsi
| `MOVsr
| `MVNi
| `MVNr
| `MVNsi
| `MVNsr
| `ORRri
| `ORRrr
| `ORRrsi
| `ORRrsr
| `RSBri
| `RSBrr
| `RSBrsi
| `RSBrsr
| `RSCri
| `RSCrr
| `RSCrsi
| `RSCrsr
| `SBCri
| `SBCrr
| `SBCrsi
| `SBCrsr
| `SUBri
| `SUBrr
| `SUBrsi
| `SUBrsr
| `TEQri
| `TEQrr
| `TEQrsi
| `TEQrsr
| `TSTri
| `TSTrr
| `TSTrsi
| `TSTrsr ]
type bits =
[ `BFC
| `BFI
| `CLZ
| `PKHTB
| `RBIT
| `REV
| `REV16
| `SBFX
| `SWPB
| `SXTAB
| `SXTAH
| `SXTB
| `SXTH
| `UBFX
| `UXTAB
| `UXTAH
| `UXTB
| `UXTH ]
type mult =
[ `MLA
| `MLS
| `MUL
| `SMLABB
| `SMLAD
| `SMLAL
| `SMLALBT
| `SMLAWB
| `SMUAD
| `SMULBB
| `SMULL
| `SMULTB
| `UMLAL
| `UMULL ]
type mem_multi =
[ `LDMDA
| `LDMDA_UPD
| `LDMDB
| `LDMDB_UPD
| `LDMIA
| `LDMIA_UPD
| `LDMIB
| `LDMIB_UPD
| `STMDA
| `STMDA_UPD
| `STMDB
| `STMDB_UPD
| `STMIA
| `STMIA_UPD
| `STMIB
| `STMIB_UPD ]
type mem =
[ `LDMDA
| `LDMDA_UPD
| `LDMDB
| `LDMDB_UPD
| `LDMIA
| `LDMIA_UPD
| `LDMIB
| `LDMIB_UPD
| `LDRBT_POST_IMM
| `LDRBT_POST_REG
| `LDRB_POST_IMM
| `LDRB_POST_REG
| `LDRB_PRE_IMM
| `LDRB_PRE_REG
| `LDRBi12
| `LDRBrs
| `LDRD
| `LDRD_POST
| `LDRD_PRE
| `LDREX
| `LDREXB
| `LDREXD
| `LDREXH
| `LDRH
| `LDRHTr
| `LDRH_POST
| `LDRH_PRE
| `LDRSB
| `LDRSBTr
| `LDRSB_POST
| `LDRSB_PRE
| `LDRSH
| `LDRSHTi
| `LDRSHTr
| `LDRSH_POST
| `LDRSH_PRE
| `LDRT_POST_REG
| `LDR_POST_IMM
| `LDR_POST_REG
| `LDR_PRE_IMM
| `LDR_PRE_REG
| `LDRi12
| `LDRrs
| `STMDA
| `STMDA_UPD
| `STMDB
| `STMDB_UPD
| `STMIA
| `STMIA_UPD
| `STMIB
| `STMIB_UPD
| `STRBT_POST_IMM
| `STRBT_POST_REG
| `STRB_POST_IMM
| `STRB_POST_REG
| `STRB_PRE_IMM
| `STRB_PRE_REG
| `STRBi12
| `STRBrs
| `STRD
| `STRD_POST
| `STRD_PRE
| `STREX
| `STREXB
| `STREXD
| `STREXH
| `STRH
| `STRHTr
| `STRH_POST
| `STRH_PRE
| `STRT_POST_REG
| `STR_POST_IMM
| `STR_POST_REG
| `STR_PRE_IMM
| `STR_PRE_REG
| `STRi12
| `STRrs ]
type branch =
[ `BL
| `BLX
| `BLX_pred
| `BLXi
| `BL_pred
| `BX
| `BX_RET
| `BX_pred
| `Bcc ]
type special =
[ `CPS2p
| `DMB
| `DSB
| `HINT
| `MRS
| `MSR
| `PLDi12
| `SVC ]
type t =
[ `ADCri
| `ADCrr
| `ADCrsi
| `ADCrsr
| `ADDri
| `ADDrr
| `ADDrsi
| `ADDrsr
| `ANDri
| `ANDrr
| `ANDrsi
| `ANDrsr
| `BFC
| `BFI
| `BICri
| `BICrr
| `BICrsi
| `BICrsr
| `BL
| `BLX
| `BLX_pred
| `BLXi
| `BL_pred
| `BX
| `BX_RET
| `BX_pred
| `Bcc
| `CLZ
| `CMNri
| `CMNzrr
| `CMNzrsi
| `CMNzrsr
| `CMPri
| `CMPrr
| `CMPrsi
| `CMPrsr
| `CPS2p
| `DMB
| `DSB
| `EORri
| `EORrr
| `EORrsi
| `EORrsr
| `HINT
| `LDMDA
| `LDMDA_UPD
| `LDMDB
| `LDMDB_UPD
| `LDMIA
| `LDMIA_UPD
| `LDMIB
| `LDMIB_UPD
| `LDRBT_POST_IMM
| `LDRBT_POST_REG
| `LDRB_POST_IMM
| `LDRB_POST_REG
| `LDRB_PRE_IMM
| `LDRB_PRE_REG
| `LDRBi12
| `LDRBrs
| `LDRD
| `LDRD_POST
| `LDRD_PRE
| `LDREX
| `LDREXB
| `LDREXD
| `LDREXH
| `LDRH
| `LDRHTr
| `LDRH_POST
| `LDRH_PRE
| `LDRSB
| `LDRSBTr
| `LDRSB_POST
| `LDRSB_PRE
| `LDRSH
| `LDRSHTi
| `LDRSHTr
| `LDRSH_POST
| `LDRSH_PRE
| `LDRT_POST_REG
| `LDR_POST_IMM
| `LDR_POST_REG
| `LDR_PRE_IMM
| `LDR_PRE_REG
| `LDRi12
| `LDRrs
| `MLA
| `MLS
| `MOVTi16
| `MOVi
| `MOVi16
| `MOVr
| `MOVsi
| `MOVsr
| `MRS
| `MSR
| `MUL
| `MVNi
| `MVNr
| `MVNsi
| `MVNsr
| `ORRri
| `ORRrr
| `ORRrsi
| `ORRrsr
| `PKHTB
| `PLDi12
| `RBIT
| `REV
| `REV16
| `RSBri
| `RSBrr
| `RSBrsi
| `RSBrsr
| `RSCri
| `RSCrr
| `RSCrsi
| `RSCrsr
| `SBCri
| `SBCrr
| `SBCrsi
| `SBCrsr
| `SBFX
| `SMLABB
| `SMLAD
| `SMLAL
| `SMLALBT
| `SMLAWB
| `SMUAD
| `SMULBB
| `SMULL
| `SMULTB
| `STMDA
| `STMDA_UPD
| `STMDB
| `STMDB_UPD
| `STMIA
| `STMIA_UPD
| `STMIB
| `STMIB_UPD
| `STRBT_POST_IMM
| `STRBT_POST_REG
| `STRB_POST_IMM
| `STRB_POST_REG
| `STRB_PRE_IMM
| `STRB_PRE_REG
| `STRBi12
| `STRBrs
| `STRD
| `STRD_POST
| `STRD_PRE
| `STREX
| `STREXB
| `STREXD
| `STREXH
| `STRH
| `STRHTr
| `STRH_POST
| `STRH_PRE
| `STRT_POST_REG
| `STR_POST_IMM
| `STR_POST_REG
| `STR_PRE_IMM
| `STR_PRE_REG
| `STRi12
| `STRrs
| `SUBri
| `SUBrr
| `SUBrsi
| `SUBrsr
| `SVC
| `SWPB
| `SXTAB
| `SXTAH
| `SXTB
| `SXTH
| `TEQri
| `TEQrr
| `TEQrsi
| `TEQrsr
| `TSTri
| `TSTrr
| `TSTrsi
| `TSTrsr
| `UBFX
| `UMLAL
| `UMULL
| `UXTAB
| `UXTAH
| `UXTB
| `UXTH ]
val create :
('a, 'b) Bap.Std.Disasm_expert.Basic.insn ->
Bap.Std.ARM.Insn.t option
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Reg :
sig
type nil = [ `Nil ]
type gpr =
[ `LR
| `PC
| `R0
| `R1
| `R10
| `R11
| `R12
| `R2
| `R3
| `R4
| `R5
| `R6
| `R7
| `R8
| `R9
| `SP ]
type gpr_or_nil =
[ `LR
| `Nil
| `PC
| `R0
| `R1
| `R10
| `R11
| `R12
| `R2
| `R3
| `R4
| `R5
| `R6
| `R7
| `R8
| `R9
| `SP ]
type ccr = [ `CPSR | `ITSTATE | `SPSR ]
type ccr_or_nil = [ `CPSR | `ITSTATE | `Nil | `SPSR ]
type non_nil =
[ `CPSR
| `ITSTATE
| `LR
| `PC
| `R0
| `R1
| `R10
| `R11
| `R12
| `R2
| `R3
| `R4
| `R5
| `R6
| `R7
| `R8
| `R9
| `SP
| `SPSR ]
type t =
[ `CPSR
| `ITSTATE
| `LR
| `Nil
| `PC
| `R0
| `R1
| `R10
| `R11
| `R12
| `R2
| `R3
| `R4
| `R5
| `R6
| `R7
| `R8
| `R9
| `SP
| `SPSR ]
val create :
Bap.Std.Disasm_expert.Basic.reg -> Bap.Std.ARM.Reg.t option
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Op :
sig
type t = Reg of Bap.Std.ARM.Reg.t | Imm of Bap.Std.word
val create : Bap.Std.op -> Bap.Std.ARM.Op.t option
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Cond :
sig
type t =
[ `AL
| `CC
| `CS
| `EQ
| `GE
| `GT
| `HI
| `LE
| `LS
| `LT
| `MI
| `NE
| `PL
| `VC
| `VS ]
val create :
Bap.Std.word -> Bap.Std.ARM.Cond.t Core_kernel.Std.Or_error.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
end
module IA32 :
sig
val lift :
Bap.Std.mem ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insn ->
Bap.Std.stmt list Core_kernel.Std.Or_error.t
module ABI : ABI
module CPU :
sig
val gpr : Var.Set.t
val mem : var
val pc : var
val sp : var
val zf : var
val cf : var
val vf : var
val nf : var
val addr_of_pc : mem -> addr
val is_reg : var -> bool
val is_flag : var -> bool
val is_sp : var -> bool
val is_bp : var -> bool
val is_pc : var -> bool
val is_zf : var -> bool
val is_cf : var -> bool
val is_vf : var -> bool
val is_nf : var -> bool
val is_mem : var -> bool
val rbp : Bap.Std.var
val rsp : Bap.Std.var
val rsi : Bap.Std.var
val rdi : Bap.Std.var
val rip : Bap.Std.var
val rax : Bap.Std.var
val rbx : Bap.Std.var
val rcx : Bap.Std.var
val rdx : Bap.Std.var
val r : Bap.Std.var array
end
end
module AMD64 :
sig
val lift :
Bap.Std.mem ->
('a, 'k) Bap.Std.Disasm_expert.Basic.insn ->
Bap.Std.stmt list Core_kernel.Std.Or_error.t
module CPU :
sig
val gpr : Var.Set.t
val mem : var
val pc : var
val sp : var
val zf : var
val cf : var
val vf : var
val nf : var
val addr_of_pc : mem -> addr
val is_reg : var -> bool
val is_flag : var -> bool
val is_sp : var -> bool
val is_bp : var -> bool
val is_pc : var -> bool
val is_zf : var -> bool
val is_cf : var -> bool
val is_vf : var -> bool
val is_nf : var -> bool
val is_mem : var -> bool
val rbp : var
val rsp : var
val rsi : var
val rdi : var
val rip : var
val rax : var
val rbx : var
val rcx : var
val rdx : var
val r : Bap.Std.var array
end
module ABI : ABI
end
module Symtab :
sig
type t = string Bap.Std.table
val create :
Bap.Std.addr list ->
Bap.Std.mem -> Bap.Std.block Bap.Std.table -> Bap.Std.Symtab.t
module Graph :
sig
type t
module V :
sig
type t
val compare : t -> t -> int
val hash : t -> int
val equal : t -> t -> bool
type label = mem * string
val create : label -> t
val label : t -> label
end
type vertex = V.t
module E :
sig
type t
val compare : t -> t -> int
type vertex = vertex
val src : t -> vertex
val dst : t -> vertex
type label = addr
val create : vertex -> label -> vertex -> t
val label : t -> label
end
type edge = E.t
val is_directed : bool
val is_empty : t -> bool
val nb_vertex : t -> int
val nb_edges : t -> int
val out_degree : t -> vertex -> int
val in_degree : t -> vertex -> int
val mem_vertex : t -> vertex -> bool
val mem_edge : t -> vertex -> vertex -> bool
val mem_edge_e : t -> edge -> bool
val find_edge : t -> vertex -> vertex -> edge
val find_all_edges : t -> vertex -> vertex -> edge list
val succ : t -> vertex -> vertex list
val pred : t -> vertex -> vertex list
val succ_e : t -> vertex -> edge list
val pred_e : t -> vertex -> edge list
val iter_vertex : (vertex -> unit) -> t -> unit
val fold_vertex : (vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges : (vertex -> vertex -> unit) -> t -> unit
val fold_edges :
(vertex -> vertex -> 'a -> 'a) -> t -> 'a -> 'a
val iter_edges_e : (edge -> unit) -> t -> unit
val fold_edges_e : (edge -> 'a -> 'a) -> t -> 'a -> 'a
val map_vertex : (vertex -> vertex) -> t -> t
val iter_succ : (vertex -> unit) -> t -> vertex -> unit
val iter_pred : (vertex -> unit) -> t -> vertex -> unit
val fold_succ : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val fold_pred : (vertex -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
val fold_succ_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
val fold_pred_e : (edge -> 'a -> 'a) -> t -> vertex -> 'a -> 'a
val empty : t
val add_vertex : t -> vertex -> t
val remove_vertex : t -> vertex -> t
val add_edge : t -> vertex -> vertex -> t
val add_edge_e : t -> edge -> t
val remove_edge : t -> vertex -> vertex -> t
val remove_edge_e : t -> edge -> t
end
val to_graph :
Bap.Std.block Bap.Std.table ->
Bap.Std.Symtab.t -> Bap.Std.Symtab.Graph.t
end
type 'a term
type program
type sub
type arg
type blk
type phi
type def
type jmp
type tid
type call
type label = Direct of Bap.Std.tid | Indirect of Bap.Std.exp
type jmp_kind =
Call of Bap.Std.call
| Goto of Bap.Std.label
| Ret of Bap.Std.label
| Int of int * Bap.Std.tid
type intent = In | Out | Both
type ('a, 'b) cls
val sub_t : (Bap.Std.program, Bap.Std.sub) Bap.Std.cls
val arg_t : (Bap.Std.sub, Bap.Std.arg) Bap.Std.cls
val blk_t : (Bap.Std.sub, Bap.Std.blk) Bap.Std.cls
val phi_t : (Bap.Std.blk, Bap.Std.phi) Bap.Std.cls
val def_t : (Bap.Std.blk, Bap.Std.def) Bap.Std.cls
val jmp_t : (Bap.Std.blk, Bap.Std.jmp) Bap.Std.cls
module Tid :
sig
type t = Bap.Std.tid
val create : unit -> Bap.Std.Tid.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Term :
sig
type 'a t = 'a Bap.Std.term
val clone : 'a Bap.Std.Term.t -> 'a Bap.Std.Term.t
val same : 'a Bap.Std.Term.t -> 'a Bap.Std.Term.t -> bool
val name : 'a Bap.Std.Term.t -> string
val tid : 'a Bap.Std.Term.t -> Bap.Std.tid
val length : ('a, 'b) Bap.Std.cls -> 'a Bap.Std.Term.t -> int
val find :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val update :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val remove :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'a Bap.Std.Term.t
val to_sequence :
?rev:bool ->
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t Bap.Std.seq
val map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t) -> 'a Bap.Std.Term.t
val filter_map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t option) ->
'a Bap.Std.Term.t
val concat_map :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> 'b Bap.Std.Term.t list) ->
'a Bap.Std.Term.t
val filter :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t ->
f:('b Bap.Std.Term.t -> bool) -> 'a Bap.Std.Term.t
val first :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t option
val last :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t option
val next :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val prev :
('a, 'b) Bap.Std.cls ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t option
val after :
('a, 'b) Bap.Std.cls ->
?rev:bool ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t Bap.Std.seq
val before :
('a, 'b) Bap.Std.cls ->
?rev:bool ->
'a Bap.Std.Term.t -> Bap.Std.tid -> 'b Bap.Std.Term.t Bap.Std.seq
val append :
('a, 'b) Bap.Std.cls ->
?after:Bap.Std.tid ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val prepend :
('a, 'b) Bap.Std.cls ->
?before:Bap.Std.tid ->
'a Bap.Std.Term.t -> 'b Bap.Std.Term.t -> 'a Bap.Std.Term.t
val set_attr :
'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'b -> 'a Bap.Std.Term.t
val get_attr : 'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'b option
val has_attr : 'a Bap.Std.Term.t -> 'b Bap.Std.tag -> bool
val del_attr :
'a Bap.Std.Term.t -> 'b Bap.Std.tag -> 'a Bap.Std.Term.t
end
module Program :
sig
type t = Bap.Std.program Bap.Std.term
val create : unit -> Bap.Std.Program.t
val lift :
Bap.Std.addr list ->
Bap.Std.block Bap.Std.table -> Bap.Std.program Bap.Std.term
val lookup :
('a, 'b) Bap.Std.cls ->
Bap.Std.Program.t -> Bap.Std.tid -> 'b Bap.Std.term option
val parent :
('a, 'b) Bap.Std.cls ->
Bap.Std.Program.t -> Bap.Std.tid -> 'a Bap.Std.term option
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?subs:int -> unit -> Bap.Std.Program.Builder.t
val add_sub :
Bap.Std.Program.Builder.t -> Bap.Std.sub Bap.Std.term -> unit
val result :
Bap.Std.Program.Builder.t -> Bap.Std.program Bap.Std.term
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Sub :
sig
type t = Bap.Std.sub Bap.Std.term
val create : ?name:string -> unit -> Bap.Std.Sub.t
val lift : Bap.Std.block -> Bap.Std.sub Bap.Std.term
val name : Bap.Std.Sub.t -> string
val with_name : Bap.Std.Sub.t -> string -> Bap.Std.Sub.t
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?args:int ->
?blks:int -> ?name:string -> unit -> Bap.Std.Sub.Builder.t
val add_blk :
Bap.Std.Sub.Builder.t -> Bap.Std.blk Bap.Std.term -> unit
val add_arg :
Bap.Std.Sub.Builder.t -> Bap.Std.arg Bap.Std.term -> unit
val result : Bap.Std.Sub.Builder.t -> Bap.Std.sub Bap.Std.term
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Blk :
sig
type t = Bap.Std.blk Bap.Std.term
type elt =
Def of Bap.Std.def Bap.Std.term
| Phi of Bap.Std.phi Bap.Std.term
| Jmp of Bap.Std.jmp Bap.Std.term
val create : unit -> Bap.Std.Blk.t
val lift : Bap.Std.block -> Bap.Std.blk Bap.Std.term list
val split_while :
Bap.Std.Blk.t ->
f:(Bap.Std.def Bap.Std.term -> bool) ->
Bap.Std.Blk.t * Bap.Std.Blk.t
val split_after :
Bap.Std.Blk.t ->
Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_before :
Bap.Std.Blk.t ->
Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_top : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
val split_bot : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
val elts :
?rev:bool -> Bap.Std.Blk.t -> Bap.Std.Blk.elt Bap.Std.seq
val dominated :
Bap.Std.Blk.t -> by:Bap.Std.tid -> Bap.Std.tid -> bool
module Builder :
sig
type t
val create :
?tid:Bap.Std.tid ->
?phis:int ->
?defs:int -> ?jmps:int -> unit -> Bap.Std.Blk.Builder.t
val add_def :
Bap.Std.Blk.Builder.t -> Bap.Std.def Bap.Std.term -> unit
val add_jmp :
Bap.Std.Blk.Builder.t -> Bap.Std.jmp Bap.Std.term -> unit
val add_phi :
Bap.Std.Blk.Builder.t -> Bap.Std.phi Bap.Std.term -> unit
val add_elt : Bap.Std.Blk.Builder.t -> Bap.Std.Blk.elt -> unit
val result : Bap.Std.Blk.Builder.t -> Bap.Std.blk Bap.Std.term
end
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Def :
sig
type t = Bap.Std.def Bap.Std.term
val create : Bap.Std.var -> Bap.Std.exp -> Bap.Std.Def.t
val lhs : Bap.Std.Def.t -> Bap.Std.var
val rhs : Bap.Std.Def.t -> Bap.Std.exp
val with_lhs : Bap.Std.Def.t -> Bap.Std.var -> Bap.Std.Def.t
val with_rhs : Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.Def.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Jmp :
sig
type t = Bap.Std.jmp Bap.Std.term
val create : ?cond:Bap.Std.exp -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
val create_call :
?cond:Bap.Std.exp -> Bap.Std.call -> Bap.Std.Jmp.t
val create_goto :
?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
val create_ret :
?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
val create_int :
?cond:Bap.Std.exp -> int -> Bap.Std.tid -> Bap.Std.Jmp.t
val kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind
val cond : Bap.Std.Jmp.t -> Bap.Std.exp
val with_cond : Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.Jmp.t
val with_kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Phi :
sig
type t = Bap.Std.phi Bap.Std.term
val create :
Bap.Std.var -> Bap.Std.def Bap.Std.term -> Bap.Std.Phi.t
val lhs : Bap.Std.Phi.t -> Bap.Std.var
val defs : Bap.Std.Phi.t -> Bap.Std.def Bap.Std.term Bap.Std.seq
val add_def :
Bap.Std.Phi.t -> Bap.Std.def Bap.Std.term -> Bap.Std.Phi.t
val remove_def : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.Phi.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Arg :
sig
type t = Bap.Std.arg Bap.Std.term
val create :
?intent:Bap.Std.intent ->
?name:string -> Bap.Std.typ -> Bap.Std.Arg.t
val var : Bap.Std.Arg.t -> Bap.Std.var
val intent : Bap.Std.Arg.t -> Bap.Std.intent option
val with_intent : Bap.Std.Arg.t -> Bap.Std.intent -> Bap.Std.Arg.t
val with_unknown_intent : Bap.Std.Arg.t -> Bap.Std.Arg.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Call :
sig
type t = Bap.Std.call
val create :
?return:Bap.Std.label ->
target:Bap.Std.label -> unit -> Bap.Std.Call.t
val target : Bap.Std.Call.t -> Bap.Std.label
val return : Bap.Std.Call.t -> Bap.Std.label option
val with_target : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
val with_return : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
val with_noreturn : Bap.Std.Call.t -> Bap.Std.Call.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Label :
sig
type t = Bap.Std.label
val create : unit -> Bap.Std.Label.t
val direct : Bap.Std.tid -> Bap.Std.Label.t
val indirect : Bap.Std.exp -> Bap.Std.Label.t
val change :
?direct:(Bap.Std.tid -> Bap.Std.tid) ->
?indirect:(Bap.Std.exp -> Bap.Std.exp) ->
Bap.Std.Label.t -> Bap.Std.Label.t
val to_string : t -> string
val str : unit -> t -> string
val pps : unit -> t -> string
val ppo : out_channel -> t -> unit
val pp : Format.formatter -> t -> unit
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness) Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list -> init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi : 'a list t -> key:Key.t -> data:'a -> 'a list t
val change : 'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t -> init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter : 'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t * [ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t = (Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) -> 'b
val fold_right : t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array : Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl = ('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list -> ('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list, ('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ -> key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ -> 'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ -> ('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t -> init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
end
module Project :
sig
type t = {
arch : Bap.Std.arch;
disasm : Bap.Std.disasm;
memory : Bap.Std.value Bap.Std.memmap;
storage : Bap.Std.dict;
program : Bap.Std.program Bap.Std.term;
symbols : string Bap.Std.table;
base : Bap.Std.mem;
}
val substitute :
?tags:string Bap.Std.tag list ->
Bap.Std.Project.t -> Bap.Std.Project.t
val register_plugin :
(Bap.Std.Project.t -> Bap.Std.Project.t) -> unit
val register_plugin' : (Bap.Std.Project.t -> unit) -> unit
val register_plugin_with_args :
(string array -> Bap.Std.Project.t -> Bap.Std.Project.t) -> unit
val register_plugin_with_args' :
(string array -> Bap.Std.Project.t -> unit) -> unit
val plugins :
unit ->
(string array -> Bap.Std.Project.t -> Bap.Std.Project.t) list
end
type project = Bap.Std.Project.t
module Dwarf :
sig
module Leb128 :
sig
type t
type 'a encoder = ?signed:bool -> 'a -> Bap.Std.Dwarf.Leb128.t
type 'a decoder =
Bap.Std.Dwarf.Leb128.t -> 'a Core_kernel.Std.Or_error.t
val size : Bap.Std.Dwarf.Leb128.t -> int
val read :
?signed:bool ->
string ->
pos_ref:int Pervasives.ref ->
Bap.Std.Dwarf.Leb128.t Core_kernel.Std.Or_error.t
val write : Bap.Std.Dwarf.Leb128.t -> string -> pos:int -> unit
val to_int : int Bap.Std.Dwarf.Leb128.decoder
val to_int32 : int32 Bap.Std.Dwarf.Leb128.decoder
val to_int64 : int64 Bap.Std.Dwarf.Leb128.decoder
val of_int : int Bap.Std.Dwarf.Leb128.encoder
val of_int32 : int32 Bap.Std.Dwarf.Leb128.encoder
val of_int64 : int64 Bap.Std.Dwarf.Leb128.encoder
end
module Section : sig type t = Info | Abbrev | Str end
module Tag :
sig
type t =
Compile_unit
| Partial_unit
| Subprogram
| Entry_point
| Inlined_subroutine
| Unknown of int
end
module Attr :
sig
type t = Name | Low_pc | High_pc | Entry_pc | Unknown of int
end
type lenspec = Leb128 | One | Two | Four | Eight
module Form :
sig
type t =
Addr
| String
| Block of Bap.Std.Dwarf.lenspec
| Const of Bap.Std.Dwarf.lenspec
| Flag_present
| Strp
| Ref of Bap.Std.Dwarf.lenspec
| Indirect
| Offset
| Expr
| Sig
end
type tag = Bap.Std.Dwarf.Tag.t
type attr = Bap.Std.Dwarf.Attr.t
type form = Bap.Std.Dwarf.Form.t
type section = Bap.Std.Dwarf.Section.t
type fn
module Fn :
sig
type t = Bap.Std.Dwarf.fn
val pc_lo : Bap.Std.Dwarf.Fn.t -> Bap.Std.addr
val pc_hi : Bap.Std.Dwarf.Fn.t -> Bap.Std.addr option
val of_string : string -> t
val to_string : t -> string
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val ascending : t -> t -> int
val descending : t -> t -> int
val between : t -> low:t -> high:t -> bool
module Replace_polymorphic_compare :
sig
val ( >= ) : t -> t -> bool
val ( <= ) : t -> t -> bool
val ( = ) : t -> t -> bool
val ( > ) : t -> t -> bool
val ( < ) : t -> t -> bool
val ( <> ) : t -> t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val min : t -> t -> t
val max : t -> t -> t
val _squelch_unused_module_warning_ : unit
end
type comparator_witness
val validate_lbound :
min:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_ubound :
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val validate_bound :
min:t Core_kernel.Comparable_intf.bound ->
max:t Core_kernel.Comparable_intf.bound ->
t Core_kernel.Validate.check
val comparator :
(t, comparator_witness) Core_kernel.Comparator.comparator
module Map :
sig
module Key :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
end
module Tree :
sig
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.Tree.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked :
(Key.t * 'a) array -> 'a t
val of_tree : 'a t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b
| `Left of 'a
| `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
end
type 'a t =
(Key.t, 'a, Key.comparator_witness)
Core_kernel.Core_map.t
val empty : 'a t
val singleton : Key.t -> 'a -> 'a t
val of_alist :
(Key.t * 'a) list ->
[ `Duplicate_key of Key.t | `Ok of 'a t ]
val of_alist_or_error :
(Key.t * 'a) list -> 'a t Core_kernel.Or_error.t
val of_alist_exn : (Key.t * 'a) list -> 'a t
val of_alist_multi : (Key.t * 'a) list -> 'a list t
val of_alist_fold :
(Key.t * 'a) list ->
init:'b -> f:('b -> 'a -> 'b) -> 'b t
val of_alist_reduce :
(Key.t * 'a) list -> f:('a -> 'a -> 'a) -> 'a t
val of_sorted_array :
(Key.t * 'a) array -> 'a t Core_kernel.Or_error.t
val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
val of_tree : 'a Tree.t -> 'a t
val invariants : 'a t -> bool
val is_empty : 'a t -> bool
val length : 'a t -> int
val add : 'a t -> key:Key.t -> data:'a -> 'a t
val add_multi :
'a list t -> key:Key.t -> data:'a -> 'a list t
val change :
'a t -> Key.t -> ('a option -> 'a option) -> 'a t
val find : 'a t -> Key.t -> 'a option
val find_exn : 'a t -> Key.t -> 'a
val remove : 'a t -> Key.t -> 'a t
val mem : 'a t -> Key.t -> bool
val iter : 'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val iter2 :
'a t ->
'b t ->
f:(key:Key.t ->
data:[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
unit) ->
unit
val map : 'a t -> f:('a -> 'b) -> 'b t
val mapi : 'a t -> f:(key:Key.t -> data:'a -> 'b) -> 'b t
val fold :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val fold_right :
'a t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val filter :
'a t -> f:(key:Key.t -> data:'a -> bool) -> 'a t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter_mapi :
'a t -> f:(key:Key.t -> data:'a -> 'b option) -> 'b t
val compare_direct :
('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val keys : 'a t -> Key.t list
val data : 'a t -> 'a list
val to_alist : 'a t -> (Key.t * 'a) list
val validate :
name:(Key.t -> string) ->
'a Core_kernel.Validate.check ->
'a t Core_kernel.Validate.check
val merge :
'a t ->
'b t ->
f:(key:Key.t ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
'c t
val symmetric_diff :
'a t ->
'a t ->
data_equal:('a -> 'a -> bool) ->
(Key.t *
[ `Left of 'a | `Right of 'a | `Unequal of 'a * 'a ])
Core_kernel.Sequence.t
val min_elt : 'a t -> (Key.t * 'a) option
val min_elt_exn : 'a t -> Key.t * 'a
val max_elt : 'a t -> (Key.t * 'a) option
val max_elt_exn : 'a t -> Key.t * 'a
val for_all : 'a t -> f:('a -> bool) -> bool
val exists : 'a t -> f:('a -> bool) -> bool
val fold_range_inclusive :
'a t ->
min:Key.t ->
max:Key.t ->
init:'b -> f:(key:Key.t -> data:'a -> 'b -> 'b) -> 'b
val range_to_alist :
'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
val prev_key : 'a t -> Key.t -> (Key.t * 'a) option
val next_key : 'a t -> Key.t -> (Key.t * 'a) option
val rank : 'a t -> Key.t -> int option
val to_tree : 'a t -> 'a Tree.t
val to_sequence :
?keys_in:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Key.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Key.t ] ->
'a t -> (Key.t * 'a) Core_kernel.Sequence.t
val t_of_sexp :
(Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
val sexp_of_t :
('a -> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Set :
sig
module Elt :
sig
type t = t
type comparator_witness = comparator_witness
val comparator :
(t, comparator_witness)
Core_kernel.Comparator.comparator
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
end
module Tree :
sig
type t =
(Elt.t, Elt.comparator_witness)
Core_kernel.Core_set.Tree.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum ->
f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of
Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.Tree.t ->
f:('a -> Elt.t option) -> t
val of_tree : t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type t =
(Elt.t, Elt.comparator_witness) Core_kernel.Core_set.t
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(Elt.t -> unit) -> unit
val fold :
t ->
init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
val exists : t -> f:(Elt.t -> bool) -> bool
val for_all : t -> f:(Elt.t -> bool) -> bool
val count : t -> f:(Elt.t -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
t -> f:(Elt.t -> 'sum) -> 'sum
val find : t -> f:(Elt.t -> bool) -> Elt.t option
val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
val to_list : t -> Elt.t list
val to_array : t -> Elt.t array
val invariants : t -> bool
val mem : t -> Elt.t -> bool
val add : t -> Elt.t -> t
val remove : t -> Elt.t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare_direct : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val fold_until :
t ->
init:'b ->
f:('b -> Elt.t -> [ `Continue of 'b | `Stop of 'b ]) ->
'b
val fold_right :
t -> init:'b -> f:(Elt.t -> 'b -> 'b) -> 'b
val iter2 :
t ->
t ->
f:([ `Both of Elt.t * Elt.t
| `Left of Elt.t
| `Right of Elt.t ] -> unit) ->
unit
val filter : t -> f:(Elt.t -> bool) -> t
val partition_tf : t -> f:(Elt.t -> bool) -> t * t
val elements : t -> Elt.t list
val min_elt : t -> Elt.t option
val min_elt_exn : t -> Elt.t
val max_elt : t -> Elt.t option
val max_elt_exn : t -> Elt.t
val choose : t -> Elt.t option
val choose_exn : t -> Elt.t
val split : t -> Elt.t -> t * bool * t
val group_by :
t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
val find_index : t -> int -> Elt.t option
val remove_index : t -> int -> t
val to_tree : t -> Tree.t
val to_sequence :
?in_:[ `Decreasing_order
| `Decreasing_order_less_than_or_equal_to of Elt.t
| `Increasing_order
| `Increasing_order_greater_than_or_equal_to of
Elt.t ] ->
t -> Elt.t Core_kernel.Sequence.t
val to_map :
t ->
f:(Elt.t -> 'data) ->
(Elt.t, 'data, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t
val empty : t
val singleton : Elt.t -> t
val union_list : t list -> t
val of_list : Elt.t list -> t
val of_array : Elt.t array -> t
val of_sorted_array :
Elt.t array -> t Core_kernel.Or_error.t
val of_sorted_array_unchecked : Elt.t array -> t
val stable_dedup_list : Elt.t list -> Elt.t list
val map :
('a, 'b) Core_kernel.Core_set.t -> f:('a -> Elt.t) -> t
val filter_map :
('a, 'b) Core_kernel.Core_set.t ->
f:('a -> Elt.t option) -> t
val of_tree : Tree.t -> t
val of_map_keys :
(Elt.t, 'a, Elt.comparator_witness)
Core_kernel.Core_set_intf.Map.t -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hashable : sig type t = t end
val hash : t -> int
val hashable : t Core_kernel.Hashable.Hashtbl.Hashable.t
module Table :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Hashable.Hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Pooled_hashtbl :
sig
type key = t
type ('a, 'b) hashtbl =
('a, 'b) Core_kernel.Pooled_hashtbl.t
type 'b t = (key, 'b) hashtbl
type ('a, 'b) t_ = 'b t
type 'a key_ = key
val hashable : key Core_kernel.Core_hashtbl_intf.Hashable.t
val create :
('a key_, 'b, unit -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_key of 'a key_ | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_report_all_dups :
('a key_, 'b,
('a key_ * 'b) list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_or_error :
('a key_, 'b,
('a key_ * 'b) list ->
('a, 'b) t_ Core_kernel.Or_error.t)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_exn :
('a key_, 'b, ('a key_ * 'b) list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val of_alist_multi :
('a key_, 'b list,
('a key_ * 'b) list -> ('a, 'b list) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_mapped :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'b) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key :
('a key_, 'r,
get_key:('r -> 'a key_) ->
'r list ->
[ `Duplicate_keys of 'a key_ list | `Ok of ('a, 'r) t_ ])
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val create_with_key_exn :
('a key_, 'r,
get_key:('r -> 'a key_) -> 'r list -> ('a, 'r) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val group :
('a key_, 'b,
get_key:('r -> 'a key_) ->
get_data:('r -> 'b) ->
combine:('b -> 'b -> 'b) -> 'r list -> ('a, 'b) t_)
Core_kernel.Core_hashtbl_intf.create_options_without_hashable
val sexp_of_key : ('a, 'b) t_ -> 'a key_ -> Sexplib.Sexp.t
val clear : ('a, 'b) t_ -> unit
val copy : ('a, 'b) t_ -> ('a, 'b) t_
val invariant : ('a, 'b) t_ -> unit
val fold :
('a, 'b) t_ ->
init:'c -> f:(key:'a key_ -> data:'b -> 'c -> 'c) -> 'c
val iter :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> unit) -> unit
val existsi :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val exists : ('a, 'b) t_ -> f:('b -> bool) -> bool
val for_alli :
('a, 'b) t_ -> f:(key:'a key_ -> data:'b -> bool) -> bool
val for_all : ('a, 'b) t_ -> f:('b -> bool) -> bool
val length : ('a, 'b) t_ -> int
val is_empty : ('a, 'b) t_ -> bool
val mem : ('a, 'b) t_ -> 'a key_ -> bool
val remove : ('a, 'b) t_ -> 'a key_ -> unit
val remove_one : ('a, 'b list) t_ -> 'a key_ -> unit
val replace : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val set : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val add :
('a, 'b) t_ ->
key:'a key_ -> data:'b -> [ `Duplicate | `Ok ]
val add_exn : ('a, 'b) t_ -> key:'a key_ -> data:'b -> unit
val change :
('a, 'b) t_ ->
'a key_ -> ('b option -> 'b option) -> unit
val add_multi :
('a, 'b list) t_ -> key:'a key_ -> data:'b -> unit
val remove_multi : ('a, 'b list) t_ -> 'a key_ -> unit
val map :
('c, ('a, 'b) t_ -> f:('b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_map :
('c, ('a, 'b) t_ -> f:('b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter_mapi :
('c,
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> 'c option) -> ('a, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val filter : ('a, 'b) t_ -> f:('b -> bool) -> ('a, 'b) t_
val filteri :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) -> ('a, 'b) t_
val partition_map :
('c,
('d,
('a, 'b) t_ ->
f:('b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_mapi :
('c,
('d,
('a, 'b) t_ ->
f:(key:'a key_ ->
data:'b -> [ `Fst of 'c | `Snd of 'd ]) ->
('a, 'c) t_ * ('a, 'd) t_)
Core_kernel.Core_hashtbl_intf.no_map_options)
Core_kernel.Core_hashtbl_intf.no_map_options
val partition_tf :
('a, 'b) t_ ->
f:('b -> bool) -> ('a, 'b) t_ * ('a, 'b) t_
val partitioni_tf :
('a, 'b) t_ ->
f:(key:'a key_ -> data:'b -> bool) ->
('a, 'b) t_ * ('a, 'b) t_
val find_or_add :
('a, 'b) t_ -> 'a key_ -> default:(unit -> 'b) -> 'b
val find : ('a, 'b) t_ -> 'a key_ -> 'b option
val find_exn : ('a, 'b) t_ -> 'a key_ -> 'b
val find_and_remove : ('a, 'b) t_ -> 'a key_ -> 'b option
val iter_vals : ('a, 'b) t_ -> f:('b -> unit) -> unit
val merge :
('c,
('k, 'a) t_ ->
('k, 'b) t_ ->
f:(key:'k key_ ->
[ `Both of 'a * 'b | `Left of 'a | `Right of 'b ] ->
'c option) ->
('k, 'c) t_)
Core_kernel.Core_hashtbl_intf.no_map_options
val merge_into :
f:(key:'a key_ -> 'b -> 'b option -> 'b option) ->
src:('a, 'b) t_ -> dst:('a, 'b) t_ -> unit
val keys : ('a, 'b) t_ -> 'a key_ list
val data : ('a, 'b) t_ -> 'b list
val filter_inplace : ('a, 'b) t_ -> f:('b -> bool) -> unit
val filteri_inplace :
('a, 'b) t_ -> f:('a key_ -> 'b -> bool) -> unit
val equal :
('a, 'b) t_ -> ('a, 'b) t_ -> ('b -> 'b -> bool) -> bool
val similar :
('a, 'b1) t_ ->
('a, 'b2) t_ -> ('b1 -> 'b2 -> bool) -> bool
val to_alist : ('a, 'b) t_ -> ('a key_ * 'b) list
val validate :
name:('a key_ -> string) ->
'b Core_kernel.Validate.check ->
('a, 'b) t_ Core_kernel.Validate.check
val incr : ?by:int -> ('a, int) t_ -> 'a key_ -> unit
val t_of_sexp :
(Sexplib.Sexp.t -> 'b) -> Sexplib.Sexp.t -> 'b t
val sexp_of_t :
('b -> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
val __bin_read_t__ :
('a, int -> 'a t) Bin_prot.Read.reader1
val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
end
module Hash_set :
sig
type elt = t
type 'a hash_set = 'a Core_kernel.Hash_set.t
type t = elt hash_set
type 'a t_ = t
type 'a elt_ = elt
val create :
('a, unit -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val of_list :
('a, 'a elt_ list -> 'a t_)
Core_kernel.Hash_set_intf.create_options_without_hashable
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_writer_t : t Bin_prot.Type_class.writer
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_t : t Bin_prot.Type_class.t
end
module Hash_queue :
sig
module Key :
sig
type t = t
val hash : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val compare : t -> t -> int
end
type 'a t
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold :
'a t ->
init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
val exists : 'a t -> f:('a -> bool) -> bool
val for_all : 'a t -> f:('a -> bool) -> bool
val count : 'a t -> f:('a -> bool) -> int
val sum :
(module Core_kernel.Commutative_group.S with type t = 'sum) ->
'a t -> f:('a -> 'sum) -> 'sum
val find : 'a t -> f:('a -> bool) -> 'a option
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
val min_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val max_elt : 'a t -> cmp:('a -> 'a -> int) -> 'a option
val invariant : 'a t -> unit
val create : unit -> 'a t
val clear : 'a t -> unit
val mem : 'a t -> Key.t -> bool
val lookup : 'a t -> Key.t -> 'a option
val lookup_exn : 'a t -> Key.t -> 'a
val enqueue :
'a t -> Key.t -> 'a -> [ `Key_already_present | `Ok ]
val enqueue_exn : 'a t -> Key.t -> 'a -> unit
val first : 'a t -> 'a option
val keys : 'a t -> Key.t list
val dequeue : 'a t -> 'a option
val dequeue_exn : 'a t -> 'a
val dequeue_with_key : 'a t -> (Key.t * 'a) option
val dequeue_with_key_exn : 'a t -> Key.t * 'a
val dequeue_all : 'a t -> f:('a -> unit) -> unit
val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
val remove_exn : 'a t -> Key.t -> unit
val replace : 'a t -> Key.t -> 'a -> [ `No_such_key | `Ok ]
val replace_exn : 'a t -> Key.t -> 'a -> unit
val iteri :
'a t -> f:(key:Key.t -> data:'a -> unit) -> unit
val foldi :
'a t ->
init:'b -> f:('b -> key:Key.t -> data:'a -> 'b) -> 'b
end
val pp : Format.formatter -> t -> unit
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Bin_prot.Type_class.t
val bin_read_t : t Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
val bin_reader_t : t Bin_prot.Type_class.reader
val bin_size_t : t Bin_prot.Size.sizer
val bin_write_t : t Bin_prot.Write.writer
val bin_writer_t : t Bin_prot.Type_class.writer
end
module Buffer :
sig
type 'a t
val create : ?pos:int -> 'a -> 'a Bap.Std.Dwarf.Buffer.t
val with_pos :
'a Bap.Std.Dwarf.Buffer.t -> int -> 'a Bap.Std.Dwarf.Buffer.t
val with_off :
'a Bap.Std.Dwarf.Buffer.t -> int -> 'a Bap.Std.Dwarf.Buffer.t
val pos : 'a Bap.Std.Dwarf.Buffer.t -> int
val data : 'a Bap.Std.Dwarf.Buffer.t -> 'a
end
module Data :
sig
type 'a t
type 'a buffer = 'a Bap.Std.Dwarf.Buffer.t
val create :
Bap.Std.endian ->
(Bap.Std.Dwarf.section * 'a Bap.Std.Dwarf.Data.buffer) list ->
'a Bap.Std.Dwarf.Data.t Core_kernel.Std.Or_error.t
val section :
'a Bap.Std.Dwarf.Data.t ->
Bap.Std.Dwarf.section ->
'a Bap.Std.Dwarf.Data.buffer Core_kernel.Std.Or_error.t
val endian : 'a Bap.Std.Dwarf.Data.t -> Bap.Std.endian
end
module Fbi :
sig
type t
val create :
string Bap.Std.Dwarf.Data.t ->
Bap.Std.Dwarf.Fbi.t Core_kernel.Std.Or_error.t
val functions :
Bap.Std.Dwarf.Fbi.t ->
(string * Bap.Std.Dwarf.fn) Core_kernel.Std.Sequence.t
end
end
module Signatures :
sig
val save :
?comp:string ->
mode:string -> path:string -> Bap.Std.arch -> string -> unit
val load :
?comp:string ->
?path:string -> mode:string -> Bap.Std.arch -> string option
val default_path : string
end
module Byteweight :
sig
module type Corpus =
sig
type t
type key
val look :
Bap.Std.Byteweight.Corpus.t ->
length:int -> int -> Bap.Std.Byteweight.Corpus.key option
end
module type S =
sig
type t
type key
type corpus
val create : unit -> Bap.Std.Byteweight.S.t
val train :
Bap.Std.Byteweight.S.t ->
max_length:int ->
(Bap.Std.Byteweight.S.key -> bool) ->
Bap.Std.Byteweight.S.corpus -> unit
val length : Bap.Std.Byteweight.S.t -> int
val next :
Bap.Std.Byteweight.S.t ->
length:int ->
threshold:float ->
Bap.Std.Byteweight.S.corpus -> int -> int option
val pp : Bap.Std.Byteweight.S.t Bap.Std.printer
end
module Make :
functor (Corpus : Corpus) ->
functor
(Trie : sig
type 'a t
type key = Corpus.key
val create : unit -> 'a t
val add : 'a t -> key:key -> data:'a -> unit
val change :
'a t -> key -> ('a option -> 'a option) -> unit
val find : 'a t -> key -> 'a option
val remove : 'a t -> key -> unit
val longest_match :
'a t -> key -> (int * 'a) option
val length : 'a t -> int
val pp : 'a printer -> 'a t printer
end) ->
sig
type t
type key = Corpus.key
type corpus = Corpus.t
val create : unit -> t
val train :
t -> max_length:int -> (key -> bool) -> corpus -> unit
val length : t -> int
val next :
t ->
length:int ->
threshold:float -> corpus -> int -> int option
val pp : t printer
end
module Bytes :
sig
type t
type key = mem
type corpus = mem
val create : unit -> t
val train :
t -> max_length:int -> (key -> bool) -> corpus -> unit
val length : t -> int
val next :
t ->
length:int -> threshold:float -> corpus -> int -> int option
val pp : t printer
val find :
t ->
length:int -> threshold:float -> corpus -> Bap.Std.addr list
end
end
end
end